GCC Code Coverage Report

Directory: ./
File: sql/binlog.cc
Date: 2022-12-06 21:40:42
Exec Total Coverage
Lines: 4179 4572 91.4%
Branches: 5181 9325 55.6%
Line Branch Exec Source
1 /* Copyright (c) 2009, 2022, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23 #include "sql/binlog.h"
24
25 #include "my_config.h"
26
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <limits.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <time.h>
33
34 #include "lex_string.h"
35 #include "map_helpers.h"
36 #include "my_alloc.h"
37 #include "my_loglevel.h"
38 #include "my_macros.h"
39 #include "my_systime.h"
40 #include "my_thread.h"
41 #include "sql/check_stack.h"
42 #include "sql/clone_handler.h"
43 #include "sql_string.h"
44 #include "template_utils.h"
45 #ifdef HAVE_UNISTD_H
46 #include <unistd.h>
47 #endif
48 #include <algorithm>
49 #include <list>
50 #include <map>
51 #include <new>
52 #include <queue>
53 #include <sstream>
54 #include <string>
55
56 #include "dur_prop.h"
57 #include "libbinlogevents/include/compression/base.h"
58 #include "libbinlogevents/include/compression/iterator.h"
59 #include "libbinlogevents/include/control_events.h"
60 #include "libbinlogevents/include/debug_vars.h"
61 #include "libbinlogevents/include/rows_event.h"
62 #include "libbinlogevents/include/statement_events.h"
63 #include "libbinlogevents/include/table_id.h"
64 #include "mf_wcomp.h" // wild_one, wild_many
65 #include "mutex_lock.h" // Mutex_lock
66 #include "my_base.h"
67 #include "my_bitmap.h"
68 #include "my_byteorder.h"
69 #include "my_compiler.h"
70 #include "my_dbug.h"
71 #include "my_dir.h"
72 #include "my_sqlcommand.h"
73 #include "my_stacktrace.h" // my_safe_print_system_time
74 #include "my_thread_local.h"
75 #include "mysql/components/services/log_builtins.h"
76 #include "mysql/plugin.h"
77 #include "mysql/psi/mysql_file.h"
78 #include "mysql/service_mysql_alloc.h"
79 #include "mysql/thread_type.h"
80 #include "mysqld_error.h"
81 #include "partition_info.h"
82 #include "prealloced_array.h"
83 #include "sql/binlog/global.h"
84 #include "sql/binlog/recovery.h" // binlog::Binlog_recovery
85 #include "sql/binlog/tools/iterators.h"
86 #include "sql/binlog_ostream.h"
87 #include "sql/binlog_reader.h"
88 #include "sql/create_field.h"
89 #include "sql/current_thd.h"
90 #include "sql/debug_sync.h" // DEBUG_SYNC
91 #include "sql/derror.h" // ER_THD
92 #include "sql/discrete_interval.h"
93 #include "sql/field.h"
94 #include "sql/handler.h"
95 #include "sql/item_func.h" // user_var_entry
96 #include "sql/key.h"
97 #include "sql/log.h"
98 #include "sql/log_event.h" // Rows_log_event
99 #include "sql/mysqld.h" // sync_binlog_period ...
100 #include "sql/mysqld_thd_manager.h" // Global_THD_manager
101 #include "sql/protocol.h"
102 #include "sql/psi_memory_key.h"
103 #include "sql/query_options.h"
104 #include "sql/raii/sentry.h" // raii::Sentry<>
105 #include "sql/rpl_filter.h"
106 #include "sql/rpl_gtid.h"
107 #include "sql/rpl_handler.h" // RUN_HOOK
108 #include "sql/rpl_mi.h" // Master_info
109 #include "sql/rpl_record.h"
110 #include "sql/rpl_replica.h"
111 #include "sql/rpl_replica_commit_order_manager.h" // Commit_order_manager
112 #include "sql/rpl_rli.h" // Relay_log_info
113 #include "sql/rpl_rli_pdb.h" // Slave_worker
114 #include "sql/rpl_transaction_ctx.h"
115 #include "sql/rpl_trx_boundary_parser.h" // Transaction_boundary_parser
116 #include "sql/rpl_utility.h"
117 #include "sql/sql_backup_lock.h" // is_instance_backup_locked
118 #include "sql/sql_base.h" // find_temporary_table
119 #include "sql/sql_bitmap.h"
120 #include "sql/sql_class.h" // THD
121 #include "sql/sql_const.h"
122 #include "sql/sql_data_change.h"
123 #include "sql/sql_error.h"
124 #include "sql/sql_lex.h"
125 #include "sql/sql_list.h"
126 #include "sql/sql_parse.h" // sqlcom_can_generate_row_events
127 #include "sql/sql_show.h" // append_identifier
128 #include "sql/system_variables.h"
129 #include "sql/table.h"
130 #include "sql/transaction_info.h"
131 #include "sql/xa.h"
132 #include "sql/xa/sql_cmd_xa.h" // Sql_cmd_xa_*
133 #include "sql_partition.h"
134 #include "thr_lock.h"
135
136 class Item;
137
138 using binary_log::checksum_crc32;
139 using std::list;
140 using std::max;
141 using std::min;
142 using std::string;
143
144 #define FLAGSTR(V, F) ((V) & (F) ? #F " " : "")
145 #define YESNO(X) ((X) ? "yes" : "no")
146
147 /**
148 @defgroup Binary_Log Binary Log
149 @{
150 */
151
152 #define MY_OFF_T_UNDEF (~(my_off_t)0UL)
153
154 /*
155 Constants required for the limit unsafe warnings suppression
156 */
157 // seconds after which the limit unsafe warnings suppression will be activated
158 #define LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT 50
159 // number of limit unsafe warnings after which the suppression will be activated
160 #define LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT 50
161
162 static ulonglong limit_unsafe_suppression_start_time = 0;
163 static bool unsafe_warning_suppression_is_activated = false;
164 static int limit_unsafe_warning_count = 0;
165
166 static handlerton *binlog_hton;
167 bool opt_binlog_order_commits = true;
168
169 const char *log_bin_index = nullptr;
170 const char *log_bin_basename = nullptr;
171
172 /* Size for IO_CACHE buffer for binlog & relay log */
173 ulong rpl_read_size;
174
175 MYSQL_BIN_LOG mysql_bin_log(&sync_binlog_period);
176
177 static int binlog_init(void *p);
178 static int binlog_start_trans_and_stmt(THD *thd, Log_event *start_event);
179 static int binlog_close_connection(handlerton *hton, THD *thd);
180 static int binlog_savepoint_set(handlerton *hton, THD *thd, void *sv);
181 static int binlog_savepoint_rollback(handlerton *hton, THD *thd, void *sv);
182 static bool binlog_savepoint_rollback_can_release_mdl(handlerton *hton,
183 THD *thd);
184 static int binlog_commit(handlerton *hton, THD *thd, bool all);
185 static int binlog_rollback(handlerton *hton, THD *thd, bool all);
186 /*
187 This function is used to prepare a transaction. For the binary log SE.
188
189 @param hton The pointer to the binlog SE plugin.
190 @param thd The THD session object holding the transaction to be prepared.
191 @param all Preparing a transaction (i.e. true) or a statement
192 (i.e. false).
193
194 @return 0 if the function is successfully executed, non-zero otherwise
195 */
196 static int binlog_prepare(handlerton *hton, THD *thd, bool all);
197 /*
198 This function is used to mark an X/Open XA distributed transaction as
199 being prepared in the server transaction coordinator.
200
201 Is a no-op function, added to the handler API to workaround warnings that
202 are triggered for SEs participating in a transaction that requires this
203 callback but such callback is not available.
204
205 @param hton The pointer to the binlog SE plugin.
206 @param thd The THD session object holding the transaction to be updated.
207
208 @return 0 if the function is successfully executed, non-zero otherwise
209 */
210 static int binlog_set_prepared_in_tc(handlerton *hton, THD *thd);
211 static void exec_binlog_error_action_abort(const char *err_string);
212 static void binlog_prepare_row_images(const THD *thd, TABLE *table);
213 static bool is_loggable_xa_prepare(THD *thd);
214 static int check_instance_backup_locked();
215
216 namespace {
217 /**
218 Finishes the transaction in the engines. If the `commit_low` flag is set,
219 will commit in the engines, otherwise, if the underlying statement is an
220 `XA ROLLBACK`, it will rollback in the engines.
221
222 @param thd The THD session object holding the transaction to finalize.
223 @param all Finalizing a transaction (i.e. true) or a statement
224 (i.e. false).
225 @param run_after_commit In the case of a commit being issued, whether or
226 not to run the `after_commit` hook.
227 */
228 void finish_transaction_in_engines(THD *thd, bool all, bool run_after_commit);
229 } // namespace
230
231 2969763 bool normalize_binlog_name(char *to, const char *from, bool is_relay_log) {
232
1/2
✓ Branch 0 taken 2969763 times.
✗ Branch 1 not taken.
 2969763 DBUG_TRACE;
233 2969763 bool error = false;
234 char buff[FN_REFLEN];
235 2969763 char *ptr = const_cast<char *>(from);
236
2/2
✓ Branch 0 taken 2484370 times.
✓ Branch 1 taken 485393 times.
 2969763 char *opt_name = is_relay_log ? opt_relay_logname : opt_bin_logname;
237
238
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2969763 times.
 2969763 assert(from);
239
240 /* opt_name is not null and not empty and from is a relative path */
241
8/12
✓ Branch 0 taken 2969763 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2969763 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2969763 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2969763 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2969573 times.
✓ Branch 9 taken 190 times.
✓ Branch 10 taken 2969573 times.
✓ Branch 11 taken 190 times.
 2969763 if (opt_name && opt_name[0] && from && !test_if_hard_path(from)) {
242 // take the path from opt_name
243 // take the filename from from
244 char log_dirpart[FN_REFLEN], log_dirname[FN_REFLEN];
245 size_t log_dirpart_len, log_dirname_len;
246
1/2
✓ Branch 0 taken 2969573 times.
✗ Branch 1 not taken.
 2969573 dirname_part(log_dirpart, opt_name, &log_dirpart_len);
247
1/2
✓ Branch 0 taken 2969573 times.
✗ Branch 1 not taken.
 2969573 dirname_part(log_dirname, from, &log_dirname_len);
248
249 /* log may be empty => relay-log or log-bin did not
250 hold paths, just filename pattern */
251
2/2
✓ Branch 0 taken 54 times.
✓ Branch 1 taken 2969519 times.
 2969573 if (log_dirpart_len > 0) {
252 /* create the new path name */
253
1/2
✓ Branch 0 taken 54 times.
✗ Branch 1 not taken.
 54 if (fn_format(buff, from + log_dirname_len, log_dirpart, "",
254
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
 54 MYF(MY_UNPACK_FILENAME | MY_SAFE_PATH)) == nullptr) {
255 ✗ error = true;
256 ✗ goto end;
257 }
258
259 54 ptr = buff;
260 }
261 }
262
263
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2969763 times.
 2969763 assert(ptr);
264
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2969763 times.
 2969763 if (ptr) {
265 2969763 size_t length = strlen(ptr);
266
267 // Strips the CR+LF at the end of log name and \0-terminates it.
268
3/4
✓ Branch 0 taken 2969763 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2874514 times.
✓ Branch 3 taken 95249 times.
 2969763 if (length && ptr[length - 1] == '\n') {
269 2874514 ptr[length - 1] = 0;
270 2874514 length--;
271
2/4
✓ Branch 0 taken 2874514 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2874514 times.
 2874514 if (length && ptr[length - 1] == '\r') {
272 ✗ ptr[length - 1] = 0;
273 ✗ length--;
274 }
275 }
276
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2969763 times.
 2969763 if (!length) {
277 ✗ error = true;
278 ✗ goto end;
279 }
280
1/2
✓ Branch 0 taken 2969763 times.
✗ Branch 1 not taken.
 2969763 strmake(to, ptr, length);
281 }
282 ✗ end:
283 2969763 return error;
284 2969763 }
285
286 static int binlog_start_consistent_snapshot(handlerton *hton, THD *thd);
287 static int binlog_clone_consistent_snapshot(handlerton *hton, THD *thd,
288 THD *from_thd);
289
290 ulonglong binlog_space_limit;
291
292 // The last published global binlog position
293 static char binlog_global_snapshot_file[FN_REFLEN];
294 static ulonglong binlog_global_snapshot_position;
295
296 // Binlog position variables for SHOW STATUS
297 static char binlog_snapshot_file[FN_REFLEN];
298 static ulonglong binlog_snapshot_position;
299 static std::string binlog_snapshot_gtid_executed;
300
301 static SHOW_VAR binlog_status_vars_detail[] = {
302 {"snapshot_file", (char *)&binlog_snapshot_file, SHOW_CHAR,
303 SHOW_SCOPE_GLOBAL},
304 {"snapshot_position", (char *)&binlog_snapshot_position, SHOW_LONGLONG,
305 SHOW_SCOPE_GLOBAL},
306 {NullS, NullS, SHOW_LONG, SHOW_SCOPE_GLOBAL}};
307
308 /**
309 @brief Checks whether purge conditions are met to be able to run purge
310 for binary log files.
311
312 This function checks whether the binary log is open, if the instance
313 is not locked for backup.
314
315 @param log The reference to the binary log.
316 @return std::pair<bool, int> the first element states whether there is a
317 purge condition violation. The second element states what is the associated
318 error code, if any.
319 */
320 8837 static std::pair<bool, int> check_purge_conditions(const MYSQL_BIN_LOG &log) {
321 // is the binary log open?
322
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8835 times.
 8837 if (!log.is_open()) {
323
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 return std::make_pair(true, 0);
324 }
325
326 // is instance locked for backup ?
327 8835 int error{0};
328
3/4
✓ Branch 0 taken 8835 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
✓ Branch 3 taken 8804 times.
 8835 if ((error = check_instance_backup_locked()) != 0) {
329
1/2
✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
 31 return std::make_pair(true, error);
330 }
331
332 // go ahead, validations checked successfully
333
1/2
✓ Branch 0 taken 8804 times.
✗ Branch 1 not taken.
 8804 return std::make_pair(false, 0);
334 }
335
336 /**
337 @brief This function abstracts the calculation of the binary log files
338 retention lower bound. It is just a function that makes it easier
339 to handle the fact that there are two mutually exclusive variables
340 that control the purge period and one of them is deprecated.
341
342 NOTE: This function and part of the purge validation functions should
343 really move to a retention policy class that abstracts the
344 retention policy altogether and its controls. Perhaps we
345 can do that once expire_logs_days is removed and a refactoring
346 is done to also include retention based on storage space
347 occupied. Then we can uses the same retention abstraction
348 for binary and relay logs and possibly extend the options
349 to retain (binary) log files not only based on time, but
350 also on space used.
351
352 @return time_t the time after which log files are considered expired.
353 */
354 39760 static time_t calculate_auto_purge_lower_time_bound() {
355
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39760 times.
 39760 if (DBUG_EVALUATE_IF("expire_logs_always", true, false)) return time(nullptr);
356
357
2/2
✓ Branch 0 taken 39724 times.
✓ Branch 1 taken 36 times.
 39760 if (binlog_expire_logs_seconds > 0)
358 39724 return time(nullptr) - binlog_expire_logs_seconds;
359
1/2
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
 36 else if (expire_logs_days > 0)
360 36 return time(nullptr) -
361 36 expire_logs_days * static_cast<time_t>(SECONDS_IN_24H);
362
363 // This function should only be called if binlog_expire_logs_seconds
364 // or expire_logs_days are greater than 0. In debug builds assert.
365 // In the event that on production builds there is ever a bug,
366 // that causes the caller to call this function with expire time set
367 // to 0, then do not purge - return 0 and thus file stat time is
368 // always greater than purge time.
369 ✗ assert(false); /* purecov: inspected */
370 return 0; /* purecov: inspected */
371 }
372
373 /**
374 @brief Checks if automatic purge conditions are met and therefore the
375 purge is allowed to be done. If not met returns true. Otherwise, false.
376
377 @return false if the check is successful. True otherwise.
378 */
379 19924 static bool check_auto_purge_conditions() {
380 // purge is disabled
381
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 19915 times.
 19924 if (!opt_binlog_expire_logs_auto_purge) return true;
382
383 // no retention window configured
384
4/4
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 19878 times.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 18 times.
 19915 if (binlog_expire_logs_seconds == 0 && expire_logs_days == 0) return true;
385
386 // retention window is set, but we are still within the window
387
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 19895 times.
 19896 if (calculate_auto_purge_lower_time_bound() < 0) return true;
388
389 // go ahead, validations checked successfully
390 19895 return false;
391 }
392
393 /**
394 Logical binlog file which wraps and hides the detail of lower layer storage
395 implementation. Binlog code just use this class to control real storage
396 */
397 class MYSQL_BIN_LOG::Binlog_ofile : public Basic_ostream {
398 public:
399 541960 ~Binlog_ofile() override {
400 270980 DBUG_TRACE;
401 270980 close();
402 270980 return;
403 541960 }
404
405 /**
406 Opens the binlog file. It opens the lower layer storage.
407
408 @param[in] log_file_key The PSI_file_key for this stream
409 @param[in] binlog_name The file to be opened
410 @param[in] flags The flags used by IO_CACHE.
411 @param[in] existing True if opening the file, false if creating a new one.
412
413 @retval false Success
414 @retval true Error
415 */
416 87303 bool open(
417 #ifdef HAVE_PSI_INTERFACE
418 PSI_file_key log_file_key,
419 #endif
420 const char *binlog_name, myf flags, bool existing = false) {
421
1/2
✓ Branch 0 taken 87303 times.
✗ Branch 1 not taken.
 87303 DBUG_TRACE;
422
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 87303 times.
 87303 assert(m_pipeline_head == nullptr);
423
424 #ifndef NDEBUG
425 {
426 #ifndef HAVE_PSI_INTERFACE
427 PSI_file_key log_file_key = PSI_NOT_INSTRUMENTED;
428 #endif
429 MY_STAT info;
430
3/4
✓ Branch 0 taken 87303 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84431 times.
✓ Branch 3 taken 2872 times.
 87303 if (!mysql_file_stat(log_file_key, binlog_name, &info, MYF(0))) {
431
2/4
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84431 times.
 84431 assert(existing == !(my_errno() == ENOENT));
432
1/2
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
 84431 set_my_errno(0);
433 }
434 }
435 #endif
436
437
2/4
✓ Branch 0 taken 87303 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 87303 times.
✗ Branch 3 not taken.
 87303 std::unique_ptr<IO_CACHE_ostream> file_ostream(new IO_CACHE_ostream);
438
2/4
✓ Branch 0 taken 87303 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 87303 times.
 87303 if (file_ostream->open(log_file_key, binlog_name, flags)) return true;
439
440 87303 m_pipeline_head = std::move(file_ostream);
441
442 /* Setup encryption for new files if needed */
443
7/8
✓ Branch 0 taken 84431 times.
✓ Branch 1 taken 2872 times.
✓ Branch 2 taken 84431 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 277 times.
✓ Branch 5 taken 84154 times.
✓ Branch 6 taken 277 times.
✓ Branch 7 taken 87026 times.
 87303 if (!existing && rpl_encryption.is_enabled()) {
444 std::unique_ptr<Binlog_encryption_ostream> encrypted_ostream(
445
1/2
✓ Branch 0 taken 277 times.
✗ Branch 1 not taken.
 277 new Binlog_encryption_ostream());
446
2/4
✓ Branch 0 taken 277 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 277 times.
 277 if (encrypted_ostream->open(std::move(m_pipeline_head))) return true;
447
1/2
✓ Branch 0 taken 277 times.
✗ Branch 1 not taken.
 277 m_encrypted_header_size = encrypted_ostream->get_header_size();
448 277 m_pipeline_head = std::move(encrypted_ostream);
449
1/2
✓ Branch 0 taken 277 times.
✗ Branch 1 not taken.
 277 }
450
451 87303 return false;
452 87303 }
453
454 /**
455 Opens an existing binlog file. It opens the lower layer storage reusing the
456 existing file password if needed.
457
458 @param[in] log_file_key The PSI_file_key for this stream
459 @param[in] binlog_name The file to be opened
460 @param[in] flags The flags used by IO_CACHE.
461
462 @retval std::unique_ptr A Binlog_ofile object pointer.
463 @retval nullptr Error.
464 */
465 2873 static std::unique_ptr<Binlog_ofile> open_existing(
466 #ifdef HAVE_PSI_INTERFACE
467 PSI_file_key log_file_key,
468 #endif
469 const char *binlog_name, myf flags) {
470
1/2
✓ Branch 0 taken 2873 times.
✗ Branch 1 not taken.
 2873 DBUG_TRACE;
471 2873 std::unique_ptr<Rpl_encryption_header> header;
472 unsigned char magic[BINLOG_MAGIC_SIZE];
473
474 /* Open a simple istream to read the magic from the file */
475
1/2
✓ Branch 0 taken 2873 times.
✗ Branch 1 not taken.
 2873 IO_CACHE_istream istream;
476
3/4
✓ Branch 0 taken 2873 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2872 times.
 2873 if (istream.open(key_file_binlog, key_file_binlog_cache, binlog_name,
477 MYF(MY_WME | MY_DONT_CHECK_FILESIZE), rpl_read_size))
478 1 return nullptr;
479
2/4
✓ Branch 0 taken 2872 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2872 times.
 2872 if (istream.read(magic, BINLOG_MAGIC_SIZE) != BINLOG_MAGIC_SIZE)
480 ✗ return nullptr;
481
482 assert(Rpl_encryption_header::ENCRYPTION_MAGIC_SIZE == BINLOG_MAGIC_SIZE);
483 /* Identify the file type by the magic to get the encryption header */
484
2/2
✓ Branch 0 taken 1092 times.
✓ Branch 1 taken 1780 times.
 2872 if (memcmp(magic, Rpl_encryption_header::ENCRYPTION_MAGIC,
485 BINLOG_MAGIC_SIZE) == 0) {
486
1/2
✓ Branch 0 taken 1092 times.
✗ Branch 1 not taken.
 1092 header = Rpl_encryption_header::get_header(&istream);
487
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1092 times.
 1092 if (header == nullptr) return nullptr;
488
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1780 times.
 1780 } else if (memcmp(magic, BINLOG_MAGIC, BINLOG_MAGIC_SIZE) != 0) {
489 ✗ return nullptr;
490 }
491
492 /* Open the binlog_ofile */
493
1/2
✓ Branch 0 taken 2872 times.
✗ Branch 1 not taken.
 2872 std::unique_ptr<Binlog_ofile> ret_ofile(new Binlog_ofile);
494
2/4
✓ Branch 0 taken 2872 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2872 times.
 2872 if (ret_ofile->open(
495 #ifdef HAVE_PSI_INTERFACE
496 log_file_key,
497 #endif
498 binlog_name, flags, true)) {
499 ✗ return nullptr;
500 }
501
502
2/2
✓ Branch 0 taken 1092 times.
✓ Branch 1 taken 1780 times.
 2872 if (header != nullptr) {
503 /* Add the encryption stream on top of IO_CACHE */
504 std::unique_ptr<Binlog_encryption_ostream> encrypted_ostream(
505
1/2
✓ Branch 0 taken 1092 times.
✗ Branch 1 not taken.
 1092 new Binlog_encryption_ostream);
506
1/2
✓ Branch 0 taken 1092 times.
✗ Branch 1 not taken.
 1092 ret_ofile->m_encrypted_header_size = header->get_header_size();
507
1/2
✓ Branch 0 taken 1092 times.
✗ Branch 1 not taken.
 2184 encrypted_ostream->open(std::move(ret_ofile->m_pipeline_head),
508 1092 std::move(header));
509 1092 ret_ofile->m_pipeline_head = std::move(encrypted_ostream);
510 1092 ret_ofile->set_encrypted();
511 1092 }
512 2872 return ret_ofile;
513 2873 }
514
515 218045 void close() {
516 218045 m_pipeline_head.reset(nullptr);
517 218045 m_position = 0;
518 218045 m_encrypted_header_size = 0;
519 218045 }
520
521 /**
522 Writes data into storage and maintains binlog position.
523
524 @param[in] buffer the data will be written
525 @param[in] length the length of the data
526
527 @retval false Success
528 @retval true Error
529 */
530 171008477 bool write(const unsigned char *buffer, my_off_t length) override {
531
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 171008459 times.
 171008477 assert(m_pipeline_head != nullptr);
532
533
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 171008430 times.
 171008459 if (m_pipeline_head->write(buffer, length)) return true;
534
535 171008430 m_position += length;
536 171008430 return false;
537 }
538
539 /**
540 Updates some bytes in the binlog file. If is only used for clearing
541 LOG_EVENT_BINLOG_IN_USE_F.
542
543 @param[in] buffer the data will be written
544 @param[in] length the length of the data
545 @param[in] offset the offset of the bytes will be updated
546
547 @retval false Success
548 @retval true Error
549 */
550 30873 bool update(const unsigned char *buffer, my_off_t length, my_off_t offset) {
551
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30873 times.
 30873 assert(m_pipeline_head != nullptr);
552
1/2
✓ Branch 0 taken 30873 times.
✗ Branch 1 not taken.
 61746 return m_pipeline_head->seek(offset) ||
553
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30873 times.
 61746 m_pipeline_head->write(buffer, length);
554 }
555
556 /**
557 Truncates some data at the end of the binlog file.
558
559 @param[in] offset where the binlog file will be truncated to.
560
561 @retval false Success
562 @retval true Error
563 */
564 12 bool truncate(my_off_t offset) {
565
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 assert(m_pipeline_head != nullptr);
566
567
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 if (m_pipeline_head->truncate(offset)) return true;
568 12 m_position = offset;
569 12 return false;
570 }
571
572 7842381 bool flush() { return m_pipeline_head->flush(); }
573 5915369 bool sync() { return m_pipeline_head->sync(); }
574
3/4
✓ Branch 0 taken 166984 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 166984 times.
 166986 bool flush_and_sync() { return flush() || sync(); }
575 33401973 my_off_t position() { return m_position; }
576 84431 bool is_empty() { return position() == 0; }
577 5783725 bool is_open() { return m_pipeline_head != nullptr; }
578 /**
579 Returns the encrypted header size of the binary log file.
580
581 @retval 0 The file is not encrypted.
582 @retval >0 The encryption header size.
583 */
584 1692343 int get_encrypted_header_size() { return m_encrypted_header_size; }
585 /**
586 Returns the real file size.
587
588 While position() returns the "file size" from the plain binary log events
589 stream point of view, this function considers the encryption header when it
590 exists.
591
592 @return The real file size considering the encryption header.
593 */
594 7974060 my_off_t get_real_file_size() { return m_position + m_encrypted_header_size; }
595 /**
596 Get the pipeline head.
597
598 @retval Returns the pipeline head or nullptr.
599 */
600 1070 std::unique_ptr<Truncatable_ostream> get_pipeline_head() {
601 1070 return std::move(m_pipeline_head);
602 }
603 /**
604 Check if the log file is encrypted.
605
606 @retval True if the log file is encrypted.
607 @retval False if the log file is not encrypted.
608 */
609 1158 bool is_encrypted() { return m_encrypted; }
610 /**
611 Set that the log file is encrypted.
612 */
613 1092 void set_encrypted() { m_encrypted = true; }
614
615 private:
616 my_off_t m_position = 0;
617 int m_encrypted_header_size = 0;
618 std::unique_ptr<Truncatable_ostream> m_pipeline_head;
619 bool m_encrypted = false;
620 };
621
622 /**
623 Helper class to switch to a new thread and then go back to the previous one,
624 when the object is destroyed using RAII.
625
626 This class is used to temporarily switch to another session (THD
627 structure). It will set up thread specific "globals" correctly
628 so that the POSIX thread looks exactly like the session attached to.
629 However, PSI_thread info is not touched as it is required to show
630 the actual physical view in PFS instrumentation i.e., it should
631 depict as the real thread doing the work instead of thread it switched
632 to.
633
634 On destruction, the original session (which is supplied to the
635 constructor) will be re-attached automatically. For example, with
636 this code, the value of @c current_thd will be the same before and
637 after execution of the code.
638
639 @code
640 {
641 for (int i = 0 ; i < count ; ++i)
642 {
643 // here we are attached to current_thd
644 // [...]
645 Thd_backup_and_restore switch_thd(current_thd, other_thd[i]);
646 // [...]
647 // here we are attached to other_thd[i]
648 // [...]
649 }
650 // here we are attached to current_thd
651 }
652 @endcode
653
654 @warning The class is not designed to be inherited from.
655 */
656
657 class Thd_backup_and_restore {
658 public:
659 /**
660 Try to attach the POSIX thread to a session.
661
662 @param[in] backup_thd The thd to restore to when object is destructed.
663 @param[in] new_thd The thd to attach to.
664 */
665
666 23701490 Thd_backup_and_restore(THD *backup_thd, THD *new_thd)
667 23701490 : m_backup_thd(backup_thd),
668 23701490 m_new_thd(new_thd),
669 23701490 m_new_thd_old_real_id(new_thd->real_id),
670 23701490 m_new_thd_old_thread_stack(new_thd->thread_stack) {
671
2/4
✓ Branch 0 taken 23701507 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23701507 times.
✗ Branch 3 not taken.
 23701490 assert(m_backup_thd != nullptr && m_new_thd != nullptr);
672 // Reset the state of the current thd.
673 23701507 m_backup_thd->restore_globals();
674
675 23701502 m_new_thd->thread_stack = m_backup_thd->thread_stack;
676 23701502 m_new_thd->store_globals();
677 #ifdef HAVE_PSI_THREAD_INTERFACE
678 23701475 PSI_THREAD_CALL(set_mem_cnt_THD)(m_new_thd, &m_backup_cnt_thd);
679 #endif
680 23701474 }
681
682 /**
683 Restores to previous thd.
684 */
685 23701506 ~Thd_backup_and_restore() {
686 /*
687 Restore the global variables of the thd we previously attached to,
688 to its original state. In other words, detach the m_new_thd.
689 */
690 23701506 m_new_thd->restore_globals();
691 23701520 m_new_thd->real_id = m_new_thd_old_real_id;
692 23701520 m_new_thd->thread_stack = m_new_thd_old_thread_stack;
693
694 // Reset the global variables to the original state.
695 23701520 m_backup_thd->store_globals();
696 #ifdef HAVE_PSI_THREAD_INTERFACE
697 23701509 PSI_THREAD_CALL(set_mem_cnt_THD)(m_backup_cnt_thd, &m_dummy_cnt_thd);
698 #endif
699 23701504 }
700
701 private:
702 THD *m_backup_thd;
703 THD *m_new_thd;
704 THD *m_backup_cnt_thd;
705 THD *m_dummy_cnt_thd;
706 my_thread_t m_new_thd_old_real_id;
707 const char *m_new_thd_old_thread_stack;
708 };
709
710 /**
711 Caches for non-transactional and transactional data before writing
712 it to the binary log.
713
714 @todo All the access functions for the flags suggest that the
715 encapsuling is not done correctly, so try to move any logic that
716 requires access to the flags into the cache.
717 */
718 class binlog_cache_data {
719 public:
720 93347 binlog_cache_data(bool trx_cache_arg, ulong *ptr_binlog_cache_use_arg,
721 ulong *ptr_binlog_cache_disk_use_arg)
722 186697 : m_pending(nullptr),
723 93350 ptr_binlog_cache_use(ptr_binlog_cache_use_arg),
724
1/2
✓ Branch 0 taken 93350 times.
✗ Branch 1 not taken.
 93347 ptr_binlog_cache_disk_use(ptr_binlog_cache_disk_use_arg) {
725 93350 flags.transactional = trx_cache_arg;
726 93350 }
727
728 93350 bool open(my_off_t cache_size, my_off_t max_cache_size) {
729 93350 return m_cache.open(cache_size, max_cache_size);
730 }
731
732 6134600 Binlog_cache_storage *get_cache() { return &m_cache; }
733 int finalize(THD *thd, Log_event *end_event);
734 int finalize(THD *thd, Log_event *end_event, XID_STATE *xs);
735 int flush(THD *thd, my_off_t *bytes, bool *wrote_xid);
736 int write_event(Log_event *event);
737 5927166 size_t get_event_counter() { return event_counter; }
738 5927057 size_t get_compressed_size() { return m_compressed_size; }
739 5927057 size_t get_decompressed_size() { return m_decompressed_size; }
740 5927057 binary_log::transaction::compression::type get_compression_type() {
741 5927057 return m_compression_type;
742 }
743
744 5927312 void set_compressed_size(size_t s) { m_compressed_size = s; }
745 5927460 void set_decompressed_size(size_t s) { m_decompressed_size = s; }
746 5927309 void set_compression_type(binary_log::transaction::compression::type t) {
747 5927309 m_compression_type = t;
748 5927309 }
749
750 180760 virtual ~binlog_cache_data() {
751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 90389 times.
 180760 assert(is_binlog_empty());
752 180778 m_cache.close();
753 }
754
755 102744958 bool is_binlog_empty() const {
756
4/4
✓ Branch 0 taken 2927 times.
✓ Branch 1 taken 102743414 times.
✓ Branch 2 taken 1662 times.
✓ Branch 3 taken 1265 times.
 102744958 DBUG_PRINT("debug", ("%s_cache - pending: 0x%llx, bytes: %llu",
757 (flags.transactional ? "trx" : "stmt"),
758 (ulonglong)pending(), (ulonglong)m_cache.length()));
759
4/4
✓ Branch 0 taken 102660735 times.
✓ Branch 1 taken 85555 times.
✓ Branch 2 taken 62808031 times.
✓ Branch 3 taken 39853908 times.
 102746341 return pending() == nullptr && m_cache.is_empty();
760 }
761
762 12158040 bool is_finalized() const { return flags.finalized; }
763
764 272497795 Rows_log_event *pending() const { return m_pending; }
765
766 36467480 void set_pending(Rows_log_event *const pending) { m_pending = pending; }
767
768 11 void set_incident(void) { flags.incident = true; }
769
770 5940055 bool has_incident(void) const { return flags.incident; }
771
772 11370971 bool has_xid() const {
773 // There should only be an XID event if we are transactional
774
5/6
✓ Branch 0 taken 5444673 times.
✓ Branch 1 taken 5926298 times.
✓ Branch 2 taken 265647 times.
✓ Branch 3 taken 5179026 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 11105324 times.
 11370971 assert((flags.transactional && flags.with_xid) || !flags.with_xid);
775 11370971 return flags.with_xid;
776 }
777
778 5927063 bool is_trx_cache() const { return flags.transactional; }
779
780 16956447 my_off_t get_byte_position() const { return m_cache.length(); }
781
782 34219621 void cache_state_checkpoint(my_off_t pos_to_checkpoint) {
783 // We only need to store the cache state for pos > 0
784
2/2
✓ Branch 0 taken 22667864 times.
✓ Branch 1 taken 11551757 times.
 34219621 if (pos_to_checkpoint) {
785 cache_state state;
786 22667864 state.with_rbr = flags.with_rbr;
787 22667864 state.with_sbr = flags.with_sbr;
788 22667864 state.with_start = flags.with_start;
789 22667864 state.with_end = flags.with_end;
790 22667864 state.with_content = flags.with_content;
791 22667864 state.event_counter = event_counter;
792
1/2
✓ Branch 0 taken 22668016 times.
✗ Branch 1 not taken.
 22667864 cache_state_map[pos_to_checkpoint] = state;
793 }
794 34219773 }
795
796 8370 void cache_state_rollback(my_off_t pos_to_rollback) {
797
2/2
✓ Branch 0 taken 7814 times.
✓ Branch 1 taken 556 times.
 8370 if (pos_to_rollback) {
798 7814 std::map<my_off_t, cache_state>::iterator it;
799
1/2
✓ Branch 0 taken 7814 times.
✗ Branch 1 not taken.
 7814 it = cache_state_map.find(pos_to_rollback);
800
1/2
✓ Branch 0 taken 7814 times.
✗ Branch 1 not taken.
 7814 if (it != cache_state_map.end()) {
801 7814 flags.with_rbr = it->second.with_rbr;
802 7814 flags.with_sbr = it->second.with_sbr;
803 7814 flags.with_start = it->second.with_start;
804 7814 flags.with_end = it->second.with_end;
805 7814 flags.with_content = it->second.with_content;
806 7814 event_counter = it->second.event_counter;
807 } else
808 ✗ assert(it == cache_state_map.end());
809 }
810 // Rolling back to pos == 0 means cleaning up the cache.
811 else {
812 556 flags.with_rbr = false;
813 556 flags.with_sbr = false;
814 556 flags.with_start = false;
815 556 flags.with_end = false;
816 556 flags.with_content = false;
817 556 event_counter = 0;
818 }
819 8370 }
820
821 /**
822 Reset the cache to unused state when the transaction is finished. It
823 drops all data in the cache and clears the flags of the transaction state.
824 */
825 5931921 virtual void reset() {
826 5931921 compute_statistics();
827 5931922 remove_pending_event();
828
829
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5931922 times.
 5931922 if (m_cache.reset()) {
830 ✗ LogErr(WARNING_LEVEL, ER_BINLOG_CANT_RESIZE_CACHE);
831 }
832
833 5931922 flags.incident = false;
834 5931922 flags.with_xid = false;
835 5931922 flags.immediate = false;
836 5931922 flags.finalized = false;
837 5931922 flags.with_sbr = false;
838 5931922 flags.with_rbr = false;
839 5931922 flags.with_start = false;
840 5931922 flags.with_end = false;
841 5931922 flags.with_content = false;
842
843 /*
844 The truncate function calls reinit_io_cache that calls my_b_flush_io_cache
845 which may increase disk_writes. This breaks the disk_writes use by the
846 binary log which aims to compute the ratio between in-memory cache usage
847 and disk cache usage. To avoid this undesirable behavior, we reset the
848 variable after truncating the cache.
849 */
850 5931922 cache_state_map.clear();
851 5931922 event_counter = 0;
852 5931922 m_compressed_size = 0;
853 5931922 m_decompressed_size = 0;
854 5931922 m_compression_type = binary_log::transaction::compression::NONE;
855
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5931922 times.
 5931922 assert(is_binlog_empty());
856 5931922 }
857
858 /**
859 Returns information about the cache content with respect to
860 the binlog_format of the events.
861
862 This will be used to set a flag on GTID_LOG_EVENT stating that the
863 transaction may have SBR statements or not, but the binlog dump
864 will show this flag as "rbr_only" when it is not set. That's why
865 an empty transaction should return true below, or else an empty
866 transaction would be assumed as "rbr_only" even not having RBR
867 events.
868
869 When dumping a binary log content using mysqlbinlog client program,
870 for any transaction assumed as "rbr_only" it will be printed a
871 statement changing the transaction isolation level to READ COMMITTED.
872 It doesn't make sense to have an empty transaction "requiring" this
873 isolation level change.
874
875 @return true The cache have SBR events or is empty.
876 @return false The cache contains a transaction with no SBR events.
877 */
878
4/4
✓ Branch 0 taken 5367249 times.
✓ Branch 1 taken 559969 times.
✓ Branch 2 taken 56251 times.
✓ Branch 3 taken 5310998 times.
 5927218 bool may_have_sbr_stmts() { return flags.with_sbr || !flags.with_rbr; }
879
880 /**
881 Check if the binlog cache contains an empty transaction, which has
882 two binlog events "BEGIN" and "COMMIT".
883
884 @return true The binlog cache contains an empty transaction.
885 @return false Otherwise.
886 */
887 884 bool has_empty_transaction() {
888 /*
889 The empty transaction has two events in trx/stmt binlog cache
890 and no changes: one is a transaction start and other is a transaction
891 end (there should be no SBR changing content and no RBR events).
892 */
893
2/2
✓ Branch 0 taken 470 times.
✓ Branch 1 taken 414 times.
 884 if (flags.with_start && // Has transaction start statement
894
1/2
✓ Branch 0 taken 470 times.
✗ Branch 1 not taken.
 470 flags.with_end && // Has transaction end statement
895
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 460 times.
 470 !flags.with_content) // Has no other content than START/END
896 {
897
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 assert(event_counter == 2); // Two events in the cache only
898
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 assert(!flags.with_sbr); // No statements changing content
899
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 assert(!flags.with_rbr); // No rows changing content
900
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 assert(!flags.immediate); // Not a DDL
901
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 assert(!flags.with_xid); // Not a XID trx and not an atomic DDL Query
902 10 return true;
903 }
904 874 return false;
905 }
906
907 /**
908 Check if the binlog cache is empty or contains an empty transaction,
909 which has two binlog events "BEGIN" and "COMMIT".
910
911 @return true The binlog cache is empty or contains an empty transaction.
912 @return false Otherwise.
913 */
914 894 bool is_empty_or_has_empty_transaction() {
915
4/4
✓ Branch 0 taken 884 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 874 times.
 894 return is_binlog_empty() || has_empty_transaction();
916 }
917
918 protected:
919 /*
920 This structure should have all cache variables/flags that should be restored
921 when a ROLLBACK TO SAVEPOINT statement be executed.
922 */
923 struct cache_state {
924 bool with_sbr;
925 bool with_rbr;
926 bool with_start;
927 bool with_end;
928 bool with_content;
929 size_t event_counter;
930 };
931 /*
932 For every SAVEPOINT used, we will store a cache_state for the current
933 binlog cache position. So, if a ROLLBACK TO SAVEPOINT is used, we can
934 restore the cache_state values after truncating the binlog cache.
935 */
936 std::map<my_off_t, cache_state> cache_state_map;
937 /*
938 In order to compute the transaction size (because of possible extra checksum
939 bytes), we need to keep track of how many events are in the binlog cache.
940 */
941 size_t event_counter = 0;
942
943 size_t m_compressed_size = 0;
944 size_t m_decompressed_size = 0;
945 binary_log::transaction::compression::type m_compression_type =
946 binary_log::transaction::compression::type::NONE;
947 /*
948 It truncates the cache to a certain position. This includes deleting the
949 pending event. It corresponds to rollback statement or rollback to
950 a savepoint. It doesn't change transaction state.
951 */
952 8370 void truncate(my_off_t pos) {
953
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8370 times.
 8370 DBUG_PRINT("info", ("truncating to position %lu", (ulong)pos));
954 8370 remove_pending_event();
955
956 // TODO: check the return value.
957 8370 (void)m_cache.truncate(pos);
958 8370 }
959
960 /**
961 Flush pending event to the cache buffer.
962 */
963 5927067 int flush_pending_event(THD *thd) {
964
2/2
✓ Branch 0 taken 15047 times.
✓ Branch 1 taken 5912020 times.
 5927067 if (m_pending) {
965 15047 m_pending->set_flags(Rows_log_event::STMT_END_F);
966
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15047 times.
 15047 if (int error = write_event(m_pending)) return error;
967 15047 thd->clear_binlog_table_maps();
968 }
969 5927067 return 0;
970 }
971
972 /**
973 Remove the pending event.
974 */
975 5948322 int remove_pending_event() {
976
2/2
✓ Branch 0 taken 15746 times.
✓ Branch 1 taken 5932576 times.
 5948322 delete m_pending;
977 5948322 m_pending = nullptr;
978 5948322 return 0;
979 }
980 struct Flags {
981 /*
982 Defines if this is either a trx-cache or stmt-cache, respectively, a
983 transactional or non-transactional cache.
984 */
985 bool transactional : 1;
986
987 /*
988 This indicates that some events did not get into the cache and most likely
989 it is corrupted.
990 */
991 bool incident : 1;
992
993 /*
994 This indicates that the cache should be written without BEGIN/END.
995 */
996 bool immediate : 1;
997
998 /*
999 This flag indicates that the buffer was finalized and has to be
1000 flushed to disk.
1001 */
1002 bool finalized : 1;
1003
1004 /*
1005 This indicates that either the cache contain an XID event, or it's
1006 an atomic DDL Query-log-event. In the latter case the flag is set up
1007 on the statement level, namely when the Query-log-event is cached
1008 at time the DDL transaction is not committing.
1009 The flag therefore gets reset when the cache is cleaned due to
1010 the statement rollback, e.g in case of a DDL post-caching execution
1011 error.
1012 Any statement scope flag among other things must consider its
1013 reset policy when the statement is rolled back.
1014 */
1015 bool with_xid : 1;
1016
1017 /*
1018 This indicates that the cache contain statements changing content.
1019 */
1020 bool with_sbr : 1;
1021
1022 /*
1023 This indicates that the cache contain RBR event changing content.
1024 */
1025 bool with_rbr : 1;
1026
1027 /*
1028 This indicates that the cache contain s transaction start statement.
1029 */
1030 bool with_start : 1;
1031
1032 /*
1033 This indicates that the cache contain a transaction end event.
1034 */
1035 bool with_end : 1;
1036
1037 /*
1038 This indicates that the cache contain content other than START/END.
1039 */
1040 bool with_content : 1;
1041 } flags;
1042
1043 virtual bool compress(THD *);
1044
1045 private:
1046 /*
1047 Storage for byte data. This binlog_cache_data will serialize
1048 events into bytes and put them into m_cache.
1049 */
1050 Binlog_cache_storage m_cache;
1051
1052 /*
1053 Pending binrows event. This event is the event where the rows are currently
1054 written.
1055 */
1056 Rows_log_event *m_pending;
1057
1058 /**
1059 This function computes binlog cache and disk usage.
1060 */
1061 5931922 void compute_statistics() {
1062
2/2
✓ Branch 0 taken 5931591 times.
✓ Branch 1 taken 331 times.
 5931922 if (!is_binlog_empty()) {
1063 5931591 (*ptr_binlog_cache_use)++;
1064
2/2
✓ Branch 0 taken 56212 times.
✓ Branch 1 taken 5875379 times.
 5931591 if (m_cache.disk_writes() != 0) (*ptr_binlog_cache_disk_use)++;
1065 }
1066 5931922 }
1067
1068 /*
1069 Stores a pointer to the status variable that keeps track of the in-memory
1070 cache usage. This corresponds to either
1071 . binlog_cache_use or binlog_stmt_cache_use.
1072 */
1073 ulong *ptr_binlog_cache_use;
1074
1075 /*
1076 Stores a pointer to the status variable that keeps track of the disk
1077 cache usage. This corresponds to either
1078 . binlog_cache_disk_use or binlog_stmt_cache_disk_use.
1079 */
1080 ulong *ptr_binlog_cache_disk_use;
1081
1082 binlog_cache_data &operator=(const binlog_cache_data &info);
1083 binlog_cache_data(const binlog_cache_data &info);
1084 };
1085
1086 class binlog_stmt_cache_data : public binlog_cache_data {
1087 public:
1088 46674 binlog_stmt_cache_data(bool trx_cache_arg, ulong *ptr_binlog_cache_use_arg,
1089 ulong *ptr_binlog_cache_disk_use_arg)
1090 46674 : binlog_cache_data(trx_cache_arg, ptr_binlog_cache_use_arg,
1091 46674 ptr_binlog_cache_disk_use_arg) {}
1092
1093 using binlog_cache_data::finalize;
1094
1095 int finalize(THD *thd);
1096 };
1097
1098 481347 int binlog_stmt_cache_data::finalize(THD *thd) {
1099
2/2
✓ Branch 0 taken 103629 times.
✓ Branch 1 taken 377718 times.
 481347 if (flags.immediate) {
1100
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 103629 times.
 103629 if (int error = finalize(thd, nullptr)) return error;
1101 } else {
1102 Query_log_event end_evt(thd, STRING_WITH_LEN("COMMIT"), false, false, true,
1103
1/2
✓ Branch 0 taken 378117 times.
✗ Branch 1 not taken.
 377718 0, true);
1104
2/4
✓ Branch 0 taken 378093 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 378093 times.
 378117 if (int error = finalize(thd, &end_evt)) return error;
1105
1/2
✓ Branch 0 taken 378075 times.
✗ Branch 1 not taken.
 378093 }
1106 481704 return 0;
1107 }
1108
1109 class binlog_trx_cache_data : public binlog_cache_data {
1110 public:
1111 46672 binlog_trx_cache_data(bool trx_cache_arg, ulong *ptr_binlog_cache_use_arg,
1112 ulong *ptr_binlog_cache_disk_use_arg)
1113 46672 : binlog_cache_data(trx_cache_arg, ptr_binlog_cache_use_arg,
1114 ptr_binlog_cache_disk_use_arg),
1115 46677 m_cannot_rollback(false),
1116 46672 before_stmt_pos(MY_OFF_T_UNDEF) {}
1117
1118 5450072 void reset() override {
1119
1/2
✓ Branch 0 taken 5450072 times.
✗ Branch 1 not taken.
 5450072 DBUG_TRACE;
1120
5/8
✓ Branch 0 taken 5450072 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5450072 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 78 times.
✓ Branch 5 taken 5449994 times.
✓ Branch 6 taken 78 times.
✗ Branch 7 not taken.
 5450072 DBUG_PRINT("enter", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos));
1121 5450072 m_cannot_rollback = false;
1122 5450072 before_stmt_pos = MY_OFF_T_UNDEF;
1123
1/2
✓ Branch 0 taken 5450072 times.
✗ Branch 1 not taken.
 5450072 binlog_cache_data::reset();
1124
5/8
✓ Branch 0 taken 5450072 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5450072 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 78 times.
✓ Branch 5 taken 5449994 times.
✓ Branch 6 taken 78 times.
✗ Branch 7 not taken.
 5450072 DBUG_PRINT("return", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos));
1125 10900144 return;
1126 5450072 }
1127
1128 19862 bool cannot_rollback() const { return m_cannot_rollback; }
1129
1130 1160 void set_cannot_rollback() { m_cannot_rollback = true; }
1131
1132 11032682 my_off_t get_prev_position() const { return before_stmt_pos; }
1133
1134 23189923 void set_prev_position(my_off_t pos) {
1135
1/2
✓ Branch 0 taken 23190501 times.
✗ Branch 1 not taken.
 23189923 DBUG_TRACE;
1136
5/8
✓ Branch 0 taken 23190307 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23190421 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 219 times.
✓ Branch 5 taken 23190202 times.
✓ Branch 6 taken 219 times.
✗ Branch 7 not taken.
 23190501 DBUG_PRINT("enter", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos));
1137 23190421 before_stmt_pos = pos;
1138
1/2
✓ Branch 0 taken 23190507 times.
✗ Branch 1 not taken.
 23190421 cache_state_checkpoint(before_stmt_pos);
1139
5/8
✓ Branch 0 taken 23190121 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23190285 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 219 times.
✓ Branch 5 taken 23190066 times.
✓ Branch 6 taken 194 times.
✗ Branch 7 not taken.
 23190507 DBUG_PRINT("return", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos));
1140 46380888 return;
1141 23190260 }
1142
1143 732 void restore_prev_position() {
1144
1/2
✓ Branch 0 taken 732 times.
✗ Branch 1 not taken.
 732 DBUG_TRACE;
1145
3/8
✓ Branch 0 taken 732 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 732 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 732 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 732 DBUG_PRINT("enter", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos));
1146
1/2
✓ Branch 0 taken 732 times.
✗ Branch 1 not taken.
 732 binlog_cache_data::truncate(before_stmt_pos);
1147
1/2
✓ Branch 0 taken 732 times.
✗ Branch 1 not taken.
 732 cache_state_rollback(before_stmt_pos);
1148 732 before_stmt_pos = MY_OFF_T_UNDEF;
1149 /*
1150 Binlog statement rollback clears with_xid now as the atomic DDL statement
1151 marker which can be set as early as at event creation and caching.
1152 */
1153 732 flags.with_xid = false;
1154
3/8
✓ Branch 0 taken 732 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 732 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 732 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 732 DBUG_PRINT("return", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos));
1155 1464 return;
1156 732 }
1157
1158 7638 void restore_savepoint(my_off_t pos) {
1159
1/2
✓ Branch 0 taken 7638 times.
✗ Branch 1 not taken.
 7638 DBUG_TRACE;
1160
3/8
✓ Branch 0 taken 7638 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7638 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 7638 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 7638 DBUG_PRINT("enter", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos));
1161
1/2
✓ Branch 0 taken 7638 times.
✗ Branch 1 not taken.
 7638 binlog_cache_data::truncate(pos);
1162
2/2
✓ Branch 0 taken 7625 times.
✓ Branch 1 taken 13 times.
 7638 if (pos <= before_stmt_pos) before_stmt_pos = MY_OFF_T_UNDEF;
1163
1/2
✓ Branch 0 taken 7638 times.
✗ Branch 1 not taken.
 7638 cache_state_rollback(pos);
1164
3/8
✓ Branch 0 taken 7638 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7638 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 7638 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 7638 DBUG_PRINT("return", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos));
1165 15276 return;
1166 7638 }
1167
1168 using binlog_cache_data::truncate;
1169
1170 int truncate(THD *thd, bool all);
1171
1172 private:
1173 /*
1174 It will be set true if any statement which cannot be rolled back safely
1175 is put in trx_cache.
1176 */
1177 bool m_cannot_rollback;
1178
1179 /*
1180 Binlog position before the start of the current statement.
1181 */
1182 my_off_t before_stmt_pos;
1183
1184 binlog_trx_cache_data &operator=(const binlog_trx_cache_data &info);
1185 binlog_trx_cache_data(const binlog_trx_cache_data &info);
1186 };
1187
1188 class binlog_cache_mngr {
1189 public:
1190 46675 binlog_cache_mngr(ulong *ptr_binlog_stmt_cache_use_arg,
1191 ulong *ptr_binlog_stmt_cache_disk_use_arg,
1192 ulong *ptr_binlog_cache_use_arg,
1193 ulong *ptr_binlog_cache_disk_use_arg)
1194 46675 : stmt_cache(false, ptr_binlog_stmt_cache_use_arg,
1195 ptr_binlog_stmt_cache_disk_use_arg),
1196
1/2
✓ Branch 0 taken 46677 times.
✗ Branch 1 not taken.
 46674 trx_cache(true, ptr_binlog_cache_use_arg,
1197 46677 ptr_binlog_cache_disk_use_arg) {}
1198
1199 46673 bool init() {
1200 46673 return stmt_cache.open(binlog_stmt_cache_size,
1201
1/2
✓ Branch 0 taken 46677 times.
✗ Branch 1 not taken.
 93354 max_binlog_stmt_cache_size) ||
1202
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46677 times.
 93354 trx_cache.open(binlog_cache_size, max_binlog_cache_size);
1203 }
1204
1205 197811455 binlog_cache_data *get_binlog_cache_data(bool is_transactional) {
1206
2/2
✓ Branch 0 taken 178709095 times.
✓ Branch 1 taken 19102360 times.
 197811455 if (is_transactional)
1207 178709095 return &trx_cache;
1208 else
1209 19102360 return &stmt_cache;
1210 }
1211
1212 103772 Binlog_cache_storage *get_stmt_cache() { return stmt_cache.get_cache(); }
1213 103865 Binlog_cache_storage *get_trx_cache() { return trx_cache.get_cache(); }
1214 /**
1215 Convenience method to check if both caches are empty.
1216 */
1217 255867 bool is_binlog_empty() const {
1218
4/4
✓ Branch 0 taken 255098 times.
✓ Branch 1 taken 847 times.
✓ Branch 2 taken 247255 times.
✓ Branch 3 taken 7863 times.
 255867 return stmt_cache.is_binlog_empty() && trx_cache.is_binlog_empty();
1219 }
1220
1221 /*
1222 clear stmt_cache and trx_cache if they are not empty
1223 */
1224 704 void reset() {
1225
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 702 times.
 704 if (!stmt_cache.is_binlog_empty()) stmt_cache.reset();
1226
2/2
✓ Branch 0 taken 688 times.
✓ Branch 1 taken 16 times.
 704 if (!trx_cache.is_binlog_empty()) trx_cache.reset();
1227 704 }
1228
1229 #ifndef NDEBUG
1230 6079064 bool dbug_any_finalized() const {
1231
3/4
✓ Branch 0 taken 6079128 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 6079035 times.
 6079064 return stmt_cache.is_finalized() || trx_cache.is_finalized();
1232 }
1233 #endif
1234
1235 /*
1236 Convenience method to flush both caches to the binary log.
1237
1238 @param bytes_written Pointer to variable that will be set to the
1239 number of bytes written for the flush.
1240 @param wrote_xid Pointer to variable that will be set to @c
1241 true if any XID event was written to the
1242 binary log. Otherwise, the variable will not
1243 be touched.
1244 @return Error code on error, zero if no error.
1245 */
1246 5926417 int flush(THD *thd, my_off_t *bytes_written, bool *wrote_xid) {
1247 5926417 my_off_t stmt_bytes = 0;
1248 5926417 my_off_t trx_bytes = 0;
1249
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5926417 times.
 5926417 assert(stmt_cache.has_xid() == 0);
1250
1/2
✓ Branch 0 taken 5926416 times.
✗ Branch 1 not taken.
 5926417 int error = stmt_cache.flush(thd, &stmt_bytes, wrote_xid);
1251
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5926415 times.
 5926416 if (error) return error;
1252
3/4
✓ Branch 0 taken 5923765 times.
✓ Branch 1 taken 2650 times.
✓ Branch 2 taken 5923765 times.
✗ Branch 3 not taken.
 5926415 DEBUG_SYNC(thd, "after_flush_stm_cache_before_flush_trx_cache");
1253
1/2
✓ Branch 0 taken 5926413 times.
✗ Branch 1 not taken.
 5926415 error = trx_cache.flush(thd, &trx_bytes, wrote_xid);
1254
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 5926410 times.
 5926413 if (error) return error;
1255 5926410 *bytes_written = stmt_bytes + trx_bytes;
1256 5926410 return 0;
1257 }
1258
1259 /**
1260 Check if at least one of transactions and statement binlog caches
1261 contains an empty transaction, other one is empty or contains an
1262 empty transaction.
1263
1264 @return true At least one of transactions and statement binlog
1265 caches an empty transaction, other one is empty
1266 or contains an empty transaction.
1267 @return false Otherwise.
1268 */
1269 884 bool has_empty_transaction() {
1270 884 return (trx_cache.is_empty_or_has_empty_transaction() &&
1271
3/4
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 874 times.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
 894 stmt_cache.is_empty_or_has_empty_transaction() &&
1272
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
 894 !is_binlog_empty());
1273 }
1274
1275 /**
1276 Check if manager contains consistent snapshot of log coordinates
1277 and gtid_executed.
1278
1279 @return true Consistent snapshot available
1280 @return false Otherwise
1281 */
1282 52042 bool has_consistent_snapshot() const {
1283 /**
1284 snapshot_gtid_executed can be empty string
1285 if gtid_mode=OFF.
1286 */
1287
1288 52042 return binlog_info.log_file_name[0] != '\0';
1289 }
1290
1291 /**
1292 Removes consistent snapshot from cache.
1293 */
1294 2085123 void drop_consistent_snapshot() {
1295 2085123 binlog_info.log_file_name[0] = '\0';
1296 2085123 snapshot_gtid_executed.clear();
1297 2085229 }
1298
1299 binlog_stmt_cache_data stmt_cache;
1300 binlog_trx_cache_data trx_cache;
1301
1302 LOG_INFO binlog_info;
1303 std::string snapshot_gtid_executed;
1304
1305 private:
1306 binlog_cache_mngr &operator=(const binlog_cache_mngr &info);
1307 binlog_cache_mngr(const binlog_cache_mngr &info);
1308 };
1309
1310 344228222 static binlog_cache_mngr *thd_get_cache_mngr(const THD *thd) {
1311 /*
1312 If opt_bin_log is not set, binlog_hton->slot == -1 and hence
1313 thd_get_ha_data(thd, hton) segfaults.
1314 */
1315
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 344228222 times.
 344228222 assert(opt_bin_log);
1316 344228222 return (binlog_cache_mngr *)thd_get_ha_data(thd, binlog_hton);
1317 }
1318
1319 /**
1320 Checks if the BINLOG_CACHE_SIZE's value is greater than MAX_BINLOG_CACHE_SIZE.
1321 If this happens, the BINLOG_CACHE_SIZE is set to MAX_BINLOG_CACHE_SIZE.
1322 */
1323 11785 void check_binlog_cache_size(THD *thd) {
1324
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 11774 times.
 11785 if (binlog_cache_size > max_binlog_cache_size) {
1325
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 if (thd) {
1326 11 push_warning_printf(
1327 thd, Sql_condition::SL_WARNING, ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX,
1328 ER_THD(thd, ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX),
1329 (ulong)binlog_cache_size, (ulong)max_binlog_cache_size);
1330 } else {
1331 ✗ LogErr(WARNING_LEVEL, ER_BINLOG_CACHE_SIZE_TOO_LARGE, binlog_cache_size,
1332 (ulong)max_binlog_cache_size);
1333 }
1334 11 binlog_cache_size = static_cast<ulong>(max_binlog_cache_size);
1335 }
1336 11785 }
1337
1338 /**
1339 Checks if the BINLOG_STMT_CACHE_SIZE's value is greater than
1340 MAX_BINLOG_STMT_CACHE_SIZE. If this happens, the BINLOG_STMT_CACHE_SIZE is set
1341 to MAX_BINLOG_STMT_CACHE_SIZE.
1342 */
1343 11776 void check_binlog_stmt_cache_size(THD *thd) {
1344
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 11767 times.
 11776 if (binlog_stmt_cache_size > max_binlog_stmt_cache_size) {
1345
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 if (thd) {
1346 9 push_warning_printf(
1347 thd, Sql_condition::SL_WARNING,
1348 ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX,
1349 ER_THD(thd, ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX),
1350 (ulong)binlog_stmt_cache_size, (ulong)max_binlog_stmt_cache_size);
1351 } else {
1352 ✗ LogErr(WARNING_LEVEL, ER_BINLOG_STMT_CACHE_SIZE_TOO_LARGE,
1353 binlog_stmt_cache_size, (ulong)max_binlog_stmt_cache_size);
1354 }
1355 9 binlog_stmt_cache_size = static_cast<ulong>(max_binlog_stmt_cache_size);
1356 }
1357 11776 }
1358
1359 /**
1360 Check whether binlog_hton has valid slot and enabled
1361 */
1362 ✗ bool binlog_enabled() {
1363 ✗ return (binlog_hton && binlog_hton->slot != HA_SLOT_UNDEF);
1364 }
1365
1366 /*
1367 Save position of binary log transaction cache.
1368
1369 SYNPOSIS
1370 binlog_trans_log_savepos()
1371
1372 thd The thread to take the binlog data from
1373 pos Pointer to variable where the position will be stored
1374
1375 DESCRIPTION
1376
1377 Save the current position in the binary log transaction cache into
1378 the variable pointed to by 'pos'
1379 */
1380
1381 11029365 static void binlog_trans_log_savepos(THD *thd, my_off_t *pos) {
1382
1/2
✓ Branch 0 taken 11029939 times.
✗ Branch 1 not taken.
 11029365 DBUG_TRACE;
1383
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11029939 times.
 11029939 assert(pos != nullptr);
1384
1/2
✓ Branch 0 taken 11030130 times.
✗ Branch 1 not taken.
 11029939 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
1385
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11029866 times.
 11030130 assert(mysql_bin_log.is_open());
1386
1/2
✓ Branch 0 taken 11029584 times.
✗ Branch 1 not taken.
 11029866 *pos = cache_mngr->trx_cache.get_byte_position();
1387
5/8
✓ Branch 0 taken 11029554 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11029621 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 84 times.
✓ Branch 5 taken 11029537 times.
✓ Branch 6 taken 84 times.
✗ Branch 7 not taken.
 11029584 DBUG_PRINT("return", ("position: %lu", (ulong)*pos));
1388
1/2
✓ Branch 0 taken 11029409 times.
✗ Branch 1 not taken.
 11029621 cache_mngr->trx_cache.cache_state_checkpoint(*pos);
1389 11029409 }
1390
1391 11293 static int binlog_dummy_recover(handlerton *, XA_recover_txn *, uint,
1392 MEM_ROOT *) {
1393 11293 return 0;
1394 }
1395
1396 /**
1397 Auxiliary class to copy serialized events to the binary log and
1398 correct some of the fields that are not known until just before
1399 writing the event.
1400
1401 This class allows feeding events in parts, so it is practical to use
1402 in do_write_cache() which reads events from an IO_CACHE where events
1403 may span multiple cache pages.
1404
1405 The following fields are fixed before writing the event:
1406 - end_log_pos is set
1407 - the checksum is computed if checksums are enabled
1408 - the length is incremented by the checksum size if checksums are enabled
1409 */
1410 class Binlog_event_writer : public Basic_ostream {
1411 MYSQL_BIN_LOG::Binlog_ofile *m_binlog_file;
1412 bool have_checksum;
1413 ha_checksum initial_checksum;
1414 ha_checksum checksum;
1415 uint32 end_log_pos;
1416 THD *thd;
1417 uchar header[LOG_EVENT_HEADER_LEN];
1418 my_off_t header_len = 0;
1419 uint32 event_len = 0;
1420
1421 public:
1422 /**
1423 Constructs a new Binlog_event_writer. Should be called once before
1424 starting to flush the transaction or statement cache to the
1425 binlog.
1426
1427 @param binlog_file to write to.
1428 @param thd_arg THD to account written binlog byte statistics to
1429 */
1430 5927064 Binlog_event_writer(MYSQL_BIN_LOG::Binlog_ofile *binlog_file, THD *thd_arg)
1431 11854128 : m_binlog_file(binlog_file),
1432 5927064 have_checksum(binlog_checksum_options !=
1433 binary_log::BINLOG_CHECKSUM_ALG_OFF),
1434 11854128 initial_checksum(my_checksum(0L, nullptr, 0)),
1435 5927064 checksum(initial_checksum),
1436 5927064 end_log_pos(binlog_file->position()),
1437
1/2
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
 5927064 thd(thd_arg) {
1438 // Simulate checksum error
1439
3/4
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 5927063 times.
 5927064 if (DBUG_EVALUATE_IF("fault_injection_crc_value", 1, 0)) checksum--;
1440 5927064 }
1441
1442 53969130 void update_header() {
1443 53969130 event_len = uint4korr(header + EVENT_LEN_OFFSET);
1444
1445 // Increase end_log_pos
1446 53969130 end_log_pos += event_len;
1447
1448 // Update event length if it has checksum
1449
2/2
✓ Branch 0 taken 53968848 times.
✓ Branch 1 taken 282 times.
 53969130 if (have_checksum) {
1450 53968848 int4store(header + EVENT_LEN_OFFSET, event_len + BINLOG_CHECKSUM_LEN);
1451 53968848 end_log_pos += BINLOG_CHECKSUM_LEN;
1452 }
1453
1454 // Store end_log_pos
1455 53969130 int4store(header + LOG_POS_OFFSET, end_log_pos);
1456 // update the checksum
1457
2/2
✓ Branch 0 taken 53968848 times.
✓ Branch 1 taken 282 times.
 53969130 if (have_checksum) checksum = my_checksum(checksum, header, header_len);
1458 53969130 }
1459
1460 24323811 bool write(const unsigned char *buffer, my_off_t length) override {
1461
1/2
✓ Branch 0 taken 24323811 times.
✗ Branch 1 not taken.
 24323811 DBUG_TRACE;
1462
1463
2/2
✓ Branch 0 taken 114479169 times.
✓ Branch 1 taken 24323811 times.
 138802980 while (length > 0) {
1464 /* Write event header into binlog */
1465
2/2
✓ Branch 0 taken 53982819 times.
✓ Branch 1 taken 60496350 times.
 114479169 if (event_len == 0) {
1466 /* data in the buf may be smaller than header size.*/
1467 uint32 header_incr =
1468 53982819 std::min<uint32>(LOG_EVENT_HEADER_LEN - header_len, length);
1469
1470 53982819 memcpy(header + header_len, buffer, header_incr);
1471 53982819 header_len += header_incr;
1472 53982819 buffer += header_incr;
1473 53982819 length -= header_incr;
1474
1475
2/2
✓ Branch 0 taken 53969130 times.
✓ Branch 1 taken 13689 times.
 53982819 if (header_len == LOG_EVENT_HEADER_LEN) {
1476
1/2
✓ Branch 0 taken 53969130 times.
✗ Branch 1 not taken.
 53969130 update_header();
1477
2/4
✓ Branch 0 taken 53969130 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 53969130 times.
 53969130 if (m_binlog_file->write(header, header_len)) return true;
1478
1479 53969130 event_len -= header_len;
1480 53969130 header_len = 0;
1481 }
1482 } else {
1483 60496350 my_off_t write_bytes = std::min<uint64>(length, event_len);
1484
1485
2/4
✓ Branch 0 taken 60496350 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 60496350 times.
 60496350 if (m_binlog_file->write(buffer, write_bytes)) return true;
1486
1487 // update the checksum
1488
2/2
✓ Branch 0 taken 60495989 times.
✓ Branch 1 taken 361 times.
 60496350 if (have_checksum)
1489
1/2
✓ Branch 0 taken 60495989 times.
✗ Branch 1 not taken.
 60495989 checksum = my_checksum(checksum, buffer, write_bytes);
1490
1491 60496350 event_len -= write_bytes;
1492 60496350 length -= write_bytes;
1493 60496350 buffer += write_bytes;
1494
1495 // The whole event is copied, now add the checksum
1496
4/4
✓ Branch 0 taken 60495989 times.
✓ Branch 1 taken 361 times.
✓ Branch 2 taken 53968848 times.
✓ Branch 3 taken 6527141 times.
 60496350 if (have_checksum && event_len == 0) {
1497 uchar checksum_buf[BINLOG_CHECKSUM_LEN];
1498
1499 53968848 int4store(checksum_buf, checksum);
1500
2/4
✓ Branch 0 taken 53968848 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 53968848 times.
 53968848 if (m_binlog_file->write(checksum_buf, BINLOG_CHECKSUM_LEN))
1501 ✗ return true;
1502 53968848 checksum = initial_checksum;
1503 }
1504 }
1505 }
1506 24323811 return false;
1507 24323811 }
1508 /**
1509 Returns true if per event checksum is enabled.
1510 */
1511 5927166 bool is_checksum_enabled() { return have_checksum; }
1512 };
1513
1514 /*
1515 this function is mostly a placeholder.
1516 conceptually, binlog initialization (now mostly done in MYSQL_BIN_LOG::open)
1517 should be moved here.
1518 */
1519
1520 11902 static int binlog_init(void *p) {
1521 11902 binlog_hton = (handlerton *)p;
1522
2/2
✓ Branch 0 taken 11357 times.
✓ Branch 1 taken 545 times.
 11902 binlog_hton->state = opt_bin_log ? SHOW_OPTION_YES : SHOW_OPTION_NO;
1523 11902 binlog_hton->db_type = DB_TYPE_BINLOG;
1524 11902 binlog_hton->savepoint_offset = sizeof(my_off_t);
1525 11902 binlog_hton->close_connection = binlog_close_connection;
1526 11902 binlog_hton->savepoint_set = binlog_savepoint_set;
1527 11902 binlog_hton->savepoint_rollback = binlog_savepoint_rollback;
1528 11902 binlog_hton->savepoint_rollback_can_release_mdl =
1529 binlog_savepoint_rollback_can_release_mdl;
1530 11902 binlog_hton->commit = binlog_commit;
1531 11902 binlog_hton->rollback = binlog_rollback;
1532 11902 binlog_hton->prepare = binlog_prepare;
1533 11902 binlog_hton->start_consistent_snapshot = binlog_start_consistent_snapshot;
1534 11902 binlog_hton->clone_consistent_snapshot = binlog_clone_consistent_snapshot;
1535 11902 binlog_hton->set_prepared_in_tc = binlog_set_prepared_in_tc;
1536 11902 binlog_hton->recover = binlog_dummy_recover;
1537 11902 binlog_hton->flags = HTON_NOT_USER_SELECTABLE | HTON_HIDDEN;
1538 11902 return 0;
1539 }
1540
1541 10286 static int binlog_deinit(void *) {
1542 /* Using binlog as TC after the binlog has been unloaded, won't work */
1543
2/2
✓ Branch 0 taken 9814 times.
✓ Branch 1 taken 472 times.
 10286 if (tc_log == &mysql_bin_log) tc_log = nullptr;
1544 10286 binlog_hton = nullptr;
1545 10286 return 0;
1546 }
1547
1548 45194 static int binlog_close_connection(handlerton *, THD *thd) {
1549
1/2
✓ Branch 0 taken 45195 times.
✗ Branch 1 not taken.
 45194 DBUG_TRACE;
1550
1/2
✓ Branch 0 taken 45195 times.
✗ Branch 1 not taken.
 45195 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
1551
2/4
✓ Branch 0 taken 45195 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 45195 times.
 45195 assert(cache_mngr->is_binlog_empty());
1552
5/8
✓ Branch 0 taken 45195 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 45195 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 45194 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
 45195 DBUG_PRINT("debug", ("Set ha_data slot %d to 0x%llx", binlog_hton->slot,
1553 (ulonglong) nullptr));
1554
1/2
✓ Branch 0 taken 45195 times.
✗ Branch 1 not taken.
 45195 thd_set_ha_data(thd, binlog_hton, nullptr);
1555 45195 cache_mngr->~binlog_cache_mngr();
1556
1/2
✓ Branch 0 taken 45194 times.
✗ Branch 1 not taken.
 45194 my_free(cache_mngr);
1557 45195 return 0;
1558 45194 }
1559
1560 48773204 int binlog_cache_data::write_event(Log_event *ev) {
1561
1/2
✓ Branch 0 taken 48775238 times.
✗ Branch 1 not taken.
 48773204 DBUG_TRACE;
1562
1563
2/2
✓ Branch 0 taken 48405987 times.
✓ Branch 1 taken 369251 times.
 48775238 if (ev != nullptr) {
1564
2/6
✓ Branch 0 taken 48405724 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 48405724 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 48405987 DBUG_EXECUTE_IF("simulate_disk_full_at_flush_pending",
1565 { DBUG_SET("+d,simulate_file_write_error"); });
1566
1567
3/4
✓ Branch 0 taken 48406075 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 61 times.
✓ Branch 3 taken 48406014 times.
 48405724 if (binary_event_serialize(ev, &m_cache)) {
1568
2/10
✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 61 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 61 DBUG_EXECUTE_IF("simulate_disk_full_at_flush_pending", {
1569 DBUG_SET("-d,simulate_file_write_error");
1570 DBUG_SET("-d,simulate_disk_full_at_flush_pending");
1571 /*
1572 after +d,simulate_file_write_error the local cache
1573 is in unsane state. Since -d,simulate_file_write_error
1574 revokes the first simulation do_write_cache()
1575 can't be run without facing an assert.
1576 So it's blocked with the following 2nd simulation:
1577 */
1578 DBUG_SET("+d,simulate_do_write_cache_failure");
1579 });
1580 61 return 1;
1581 }
1582
6/6
✓ Branch 0 taken 43285911 times.
✓ Branch 1 taken 5120097 times.
✓ Branch 2 taken 678 times.
✓ Branch 3 taken 43285369 times.
✓ Branch 4 taken 5120771 times.
✓ Branch 5 taken 43285373 times.
 91692061 if (ev->get_type_code() == binary_log::XID_EVENT ||
1583 43285911 ev->get_type_code() == binary_log::XA_PREPARE_LOG_EVENT)
1584 5120771 flags.with_xid = true;
1585
2/2
✓ Branch 0 taken 103854 times.
✓ Branch 1 taken 48302318 times.
 48406144 if (ev->is_using_immediate_logging()) flags.immediate = true;
1586 /* DDL gets marked as xid-requiring at its caching. */
1587
2/2
✓ Branch 0 taken 265694 times.
✓ Branch 1 taken 48140546 times.
 48406172 if (is_atomic_ddl_event(ev)) flags.with_xid = true;
1588 /* With respect to the event type being written */
1589
3/4
✓ Branch 0 taken 48406019 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 771536 times.
✓ Branch 3 taken 47634483 times.
 48406240 if (ev->is_sbr_logging_format()) flags.with_sbr = true;
1590
3/4
✓ Branch 0 taken 48405366 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 36491829 times.
✓ Branch 3 taken 11913537 times.
 48406019 if (ev->is_rbr_logging_format()) flags.with_rbr = true;
1591 /* With respect to empty transactions */
1592
3/4
✓ Branch 0 taken 48405379 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5562375 times.
✓ Branch 3 taken 42843004 times.
 48405366 if (ev->starts_group()) flags.with_start = true;
1593
3/4
✓ Branch 0 taken 48405612 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5558640 times.
✓ Branch 3 taken 42846972 times.
 48405379 if (ev->ends_group()) flags.with_end = true;
1594
8/10
✓ Branch 0 taken 48406160 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 42843543 times.
✓ Branch 3 taken 5562617 times.
✓ Branch 4 taken 42843587 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 37284978 times.
✓ Branch 7 taken 5558609 times.
✓ Branch 8 taken 37284995 times.
✓ Branch 9 taken 11121209 times.
 48405612 if (!ev->starts_group() && !ev->ends_group()) flags.with_content = true;
1595 48406204 event_counter++;
1596
5/8
✓ Branch 0 taken 48405215 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 48405350 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 151 times.
✓ Branch 5 taken 48405199 times.
✓ Branch 6 taken 232 times.
✗ Branch 7 not taken.
 48406204 DBUG_PRINT("debug",
1597 ("event_counter= %lu", static_cast<ulong>(event_counter)));
1598 }
1599 48774682 return 0;
1600 48774743 }
1601
1602 5823408 bool MYSQL_BIN_LOG::assign_automatic_gtids_to_flush_group(THD *first_seen) {
1603
1/2
✓ Branch 0 taken 5823408 times.
✗ Branch 1 not taken.
 5823408 DBUG_TRACE;
1604 5823408 bool error = false;
1605 5823408 bool is_global_sid_locked = false;
1606 5823408 rpl_sidno locked_sidno = 0;
1607
1608
2/2
✓ Branch 0 taken 5926417 times.
✓ Branch 1 taken 5823408 times.
 11749825 for (THD *head = first_seen; head; head = head->next_to_commit) {
1609
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5926417 times.
 5926417 assert(head->variables.gtid_next.type != UNDEFINED_GTID);
1610
1611 /* Generate GTID */
1612
2/2
✓ Branch 0 taken 5571331 times.
✓ Branch 1 taken 355086 times.
 5926417 if (head->variables.gtid_next.type == AUTOMATIC_GTID) {
1613
2/2
✓ Branch 0 taken 5484182 times.
✓ Branch 1 taken 87149 times.
 5571331 if (!is_global_sid_locked) {
1614
1/2
✓ Branch 0 taken 5484182 times.
✗ Branch 1 not taken.
 5484182 global_sid_lock->rdlock();
1615 5484182 is_global_sid_locked = true;
1616 }
1617
3/6
✓ Branch 0 taken 5571331 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5571331 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5571331 times.
✗ Branch 5 not taken.
 5571331 if (gtid_state->generate_automatic_gtid(
1618 head,
1619 head->get_transaction()->get_rpl_transaction_ctx()->get_sidno(),
1620 head->get_transaction()->get_rpl_transaction_ctx()->get_gno(),
1621
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5571330 times.
 5571331 &locked_sidno) != RETURN_STATUS_OK) {
1622 1 head->commit_error = THD::CE_FLUSH_GNO_EXHAUSTED_ERROR;
1623 1 error = true;
1624 }
1625 } else {
1626
3/8
✓ Branch 0 taken 355086 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 355086 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 355086 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 355086 DBUG_PRINT("info",
1627 ("thd->variables.gtid_next.type=%d "
1628 "thd->owned_gtid.sidno=%d",
1629 head->variables.gtid_next.type, head->owned_gtid.sidno));
1630
2/2
✓ Branch 0 taken 84447 times.
✓ Branch 1 taken 270639 times.
 355086 if (head->variables.gtid_next.type == ASSIGNED_GTID)
1631
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84447 times.
 84447 assert(head->owned_gtid.sidno > 0);
1632 else {
1633
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 270639 times.
 270639 assert(head->variables.gtid_next.type == ANONYMOUS_GTID);
1634
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 270639 times.
 270639 assert(head->owned_gtid.sidno == THD::OWNED_SIDNO_ANONYMOUS);
1635 }
1636 }
1637 }
1638
1639
3/4
✓ Branch 0 taken 119313 times.
✓ Branch 1 taken 5704095 times.
✓ Branch 2 taken 119313 times.
✗ Branch 3 not taken.
 5823408 if (locked_sidno > 0) gtid_state->unlock_sidno(locked_sidno);
1640
1641
3/4
✓ Branch 0 taken 5484182 times.
✓ Branch 1 taken 339226 times.
✓ Branch 2 taken 5484182 times.
✗ Branch 3 not taken.
 5823408 if (is_global_sid_locked) global_sid_lock->unlock();
1642
1643 5823408 return error;
1644 5823408 }
1645
1646 /**
1647 Write the Gtid_log_event to the binary log (prior to writing the
1648 statement or transaction cache).
1649
1650 @param thd Thread that is committing.
1651 @param cache_data The cache that is flushing.
1652 @param writer The event will be written to this Binlog_event_writer object.
1653
1654 @retval false Success.
1655 @retval true Error.
1656 */
1657 5927063 bool MYSQL_BIN_LOG::write_transaction(THD *thd, binlog_cache_data *cache_data,
1658 Binlog_event_writer *writer) {
1659
1/2
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
 5927063 DBUG_TRACE;
1660
1661 /*
1662 The GTID for the THD was assigned at
1663 assign_automatic_gtids_to_flush_group()
1664 */
1665
3/4
✓ Branch 0 taken 203805 times.
✓ Branch 1 taken 5723258 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 203805 times.
 5927063 assert(thd->owned_gtid.sidno == THD::OWNED_SIDNO_ANONYMOUS ||
1666 thd->owned_gtid.sidno > 0);
1667
1668 int64 sequence_number, last_committed;
1669 /* Generate logical timestamps for MTS */
1670
1/2
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
 5927063 m_dependency_tracker.get_dependency(thd, sequence_number, last_committed);
1671
1672 /*
1673 In case both the transaction cache and the statement cache are
1674 non-empty, both will be flushed in sequence and logged as
1675 different transactions. Then the second transaction must only
1676 be executed after the first one has committed. Therefore, we
1677 need to set last_committed for the second transaction equal to
1678 last_committed for the first transaction. This is done in
1679 binlog_cache_data::flush. binlog_cache_data::flush uses the
1680 condition trn_ctx->last_committed==SEQ_UNINIT to detect this
1681 situation, hence the need to set it here.
1682 */
1683 5927063 thd->get_transaction()->last_committed = SEQ_UNINIT;
1684
1685 /*
1686 For delayed replication and also for the purpose of lag monitoring,
1687 we assume that the commit timestamp of the transaction is the time of
1688 executing this code (the time of writing the Gtid_log_event to the binary
1689 log).
1690 */
1691 5927063 ulonglong immediate_commit_timestamp = my_micro_time();
1692
1693 /*
1694 When the original_commit_timestamp session variable is set to a value
1695 other than UNDEFINED_COMMIT_TIMESTAMP, it means that either the timestamp
1696 is known ( > 0 ) or the timestamp is not known ( == 0 ).
1697 */
1698 5927063 ulonglong original_commit_timestamp =
1699 thd->variables.original_commit_timestamp;
1700 /*
1701 When original_commit_timestamp == UNDEFINED_COMMIT_TIMESTAMP, we assume
1702 that:
1703 a) it is not known if this thread is a slave applier ( = 0 );
1704 b) this is a new transaction ( = immediate_commit_timestamp);
1705 */
1706
2/2
✓ Branch 0 taken 5590890 times.
✓ Branch 1 taken 336173 times.
 5927063 if (original_commit_timestamp == UNDEFINED_COMMIT_TIMESTAMP) {
1707 /*
1708 When applying a transaction using replication, assume that the
1709 original commit timestamp is not known (the transaction wasn't
1710 originated on the current server).
1711 */
1712
6/6
✓ Branch 0 taken 5590763 times.
✓ Branch 1 taken 127 times.
✓ Branch 2 taken 46 times.
✓ Branch 3 taken 5590717 times.
✓ Branch 4 taken 173 times.
✓ Branch 5 taken 5590717 times.
 5590890 if (thd->slave_thread || thd->is_binlog_applier()) {
1713 173 original_commit_timestamp = 0;
1714 } else
1715 /* Assume that this transaction is original from this server */
1716 {
1717
2/4
✓ Branch 0 taken 5590717 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5590717 times.
 5590717 DBUG_EXECUTE_IF("rpl_invalid_gtid_timestamp",
1718 // add one our to the commit timestamps
1719 immediate_commit_timestamp += 3600000000;);
1720 5590717 original_commit_timestamp = immediate_commit_timestamp;
1721 }
1722 } else {
1723 // Clear the session variable to have cleared states for next transaction.
1724 336173 thd->variables.original_commit_timestamp = UNDEFINED_COMMIT_TIMESTAMP;
1725 }
1726
1727 uint32_t trx_immediate_server_version =
1728 5927063 do_server_version_int(::server_version);
1729 // Clear the session variable to have cleared states for next transaction.
1730 5927063 thd->variables.immediate_server_version = UNDEFINED_SERVER_VERSION;
1731
3/4
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 5927061 times.
 5927063 DBUG_EXECUTE_IF("fixed_server_version",
1732 trx_immediate_server_version = 888888;);
1733
2/4
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5927063 times.
 5927063 DBUG_EXECUTE_IF("gr_fixed_server_version",
1734 trx_immediate_server_version = 777777;);
1735
1736 /*
1737 When the original_server_version session variable is set to a value
1738 other than UNDEFINED_SERVER_VERSION, it means that either the
1739 server version is known or the server_version is not known
1740 (UNKNOWN_SERVER_VERSION).
1741 */
1742 5927063 uint32_t trx_original_server_version = thd->variables.original_server_version;
1743
1744 /*
1745 When original_server_version == UNDEFINED_SERVER_VERSION, we assume
1746 that:
1747 a) it is not known if this thread is a slave applier ( = 0 );
1748 b) this is a new transaction ( = ::server_version);
1749 */
1750
2/2
✓ Branch 0 taken 5590910 times.
✓ Branch 1 taken 336153 times.
 5927063 if (trx_original_server_version == UNDEFINED_SERVER_VERSION) {
1751 /*
1752 When applying a transaction using replication, assume that the
1753 original server version is not known (the transaction wasn't
1754 originated on the current server).
1755 */
1756
6/6
✓ Branch 0 taken 5590757 times.
✓ Branch 1 taken 153 times.
✓ Branch 2 taken 40 times.
✓ Branch 3 taken 5590717 times.
✓ Branch 4 taken 193 times.
✓ Branch 5 taken 5590717 times.
 5590910 if (thd->slave_thread || thd->is_binlog_applier()) {
1757 193 trx_original_server_version = UNKNOWN_SERVER_VERSION;
1758 } else
1759 /* Assume that this transaction is original from this server */
1760 {
1761 5590717 trx_original_server_version = trx_immediate_server_version;
1762 }
1763 } else {
1764 // Clear the session variable to have cleared states for next transaction.
1765 336153 thd->variables.original_server_version = UNDEFINED_SERVER_VERSION;
1766 }
1767 Gtid_log_event gtid_event(
1768 5927063 thd, cache_data->is_trx_cache(), last_committed, sequence_number,
1769 5927063 cache_data->may_have_sbr_stmts(), original_commit_timestamp,
1770 immediate_commit_timestamp, trx_original_server_version,
1771
1/2
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
 5927063 trx_immediate_server_version);
1772
1773 // Set the transaction length, based on cache info
1774
2/4
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927063 times.
✗ Branch 3 not taken.
 5927063 gtid_event.set_trx_length_by_cache_size(cache_data->get_byte_position(),
1775 5927063 writer->is_checksum_enabled(),
1776 5927063 cache_data->get_event_counter());
1777
1778
6/10
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927063 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 103 times.
✓ Branch 5 taken 5926960 times.
✓ Branch 6 taken 103 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 103 times.
✗ Branch 9 not taken.
 5927063 DBUG_PRINT("debug", ("cache_data->get_byte_position()= %llu",
1779 cache_data->get_byte_position()));
1780
5/8
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927063 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 103 times.
✓ Branch 5 taken 5926960 times.
✓ Branch 6 taken 103 times.
✗ Branch 7 not taken.
 5927063 DBUG_PRINT("debug", ("cache_data->get_event_counter()= %lu",
1781 static_cast<ulong>(cache_data->get_event_counter())));
1782
6/10
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927063 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 103 times.
✓ Branch 5 taken 5926960 times.
✓ Branch 6 taken 103 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 103 times.
✗ Branch 9 not taken.
 5927063 DBUG_PRINT("debug", ("writer->is_checksum_enabled()= %s",
1783 YESNO(writer->is_checksum_enabled())));
1784
6/10
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927063 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 103 times.
✓ Branch 5 taken 5926960 times.
✓ Branch 6 taken 103 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 103 times.
✗ Branch 9 not taken.
 5927063 DBUG_PRINT("debug", ("gtid_event.get_event_length()= %lu",
1785 static_cast<ulong>(gtid_event.get_event_length())));
1786
5/8
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927063 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 106 times.
✓ Branch 5 taken 5926957 times.
✓ Branch 6 taken 106 times.
✗ Branch 7 not taken.
 5927063 DBUG_PRINT("info",
1787 ("transaction_length= %llu", gtid_event.transaction_length));
1788
1789
1/2
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
 5927063 bool ret = gtid_event.write(writer);
1790
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5927063 times.
 5927063 if (ret) goto end;
1791
1792 /*
1793 finally write the transaction data, if it was not compressed
1794 and written as part of the gtid event already
1795 */
1796
1/2
✓ Branch 0 taken 5927060 times.
✗ Branch 1 not taken.
 5927063 ret = mysql_bin_log.write_cache(thd, cache_data, writer);
1797
1798
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 5927057 times.
 5927060 if (!ret) {
1799 // update stats if monitoring is active
1800
1/2
✓ Branch 0 taken 5927057 times.
✗ Branch 1 not taken.
 5927057 binlog::global_context.monitoring_context()
1801
1/2
✓ Branch 0 taken 5927057 times.
✗ Branch 1 not taken.
 5927057 .transaction_compression()
1802
1/2
✓ Branch 0 taken 5927057 times.
✗ Branch 1 not taken.
 11854114 .update(binlog::monitoring::log_type::BINARY,
1803 5927057 cache_data->get_compression_type(), thd->owned_gtid,
1804 5927057 gtid_event.immediate_commit_timestamp,
1805 cache_data->get_compressed_size(),
1806 cache_data->get_decompressed_size());
1807 }
1808
1809 3 end:
1810 5927060 return ret;
1811 5927060 }
1812
1813 1704587 int MYSQL_BIN_LOG::gtid_end_transaction(THD *thd) {
1814
1/2
✓ Branch 0 taken 1704895 times.
✗ Branch 1 not taken.
 1704587 DBUG_TRACE;
1815
1816
5/10
✓ Branch 0 taken 1704887 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1704916 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 87 times.
✓ Branch 5 taken 1704829 times.
✓ Branch 6 taken 87 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 1704895 DBUG_PRINT("info", ("query=%s", thd->query().str));
1817
1818
2/2
✓ Branch 0 taken 50479 times.
✓ Branch 1 taken 1654139 times.
 1704618 if (thd->owned_gtid.sidno > 0) {
1819
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50479 times.
 50479 assert(thd->variables.gtid_next.type == ASSIGNED_GTID);
1820
1821
5/6
✓ Branch 0 taken 50455 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 20139 times.
✓ Branch 3 taken 30316 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 20139 times.
 50479 if (!opt_bin_log || (thd->slave_thread && !opt_log_replica_updates)) {
1822 /*
1823 If the binary log is disabled for this thread (either by
1824 log_bin=0 or sql_log_bin=0 or by log_replica_updates=0 for a
1825 slave thread), then the statement must not be written to the
1826 binary log. In this case, we just save the GTID into the
1827 table directly.
1828
1829 (This only happens for DDL, since DML will save the GTID into
1830 table and release ownership inside ha_commit_trans.)
1831 */
1832
2/4
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24 times.
 24 if (gtid_state->save(thd) != 0) {
1833 ✗ gtid_state->update_on_rollback(thd);
1834 ✗ return 1;
1835
3/4
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 17 times.
 24 } else if (!has_commit_order_manager(thd)) {
1836 /*
1837 The gtid_state->save implicitly performs the commit, in the following
1838 stack:
1839 Gtid_state::save ->
1840 Gtid_table_persistor::save ->
1841 Gtid_table_access_context::deinit ->
1842 System_table_access::close_table ->
1843 ha_commit_trans ->
1844 Relay_log_info::pre_commit ->
1845 Slave_worker::commit_positions(THD*) ->
1846 Slave_worker::commit_positions(THD*,Log_event*,...) ->
1847 Slave_worker::flush_info ->
1848 Rpl_info_handler::flush_info ->
1849 Rpl_info_table::do_flush_info ->
1850 Rpl_info_table_access::close_table ->
1851 System_table_access::close_table ->
1852 ha_commit_trans ->
1853 MYSQL_BIN_LOG::commit ->
1854 ha_commit_low
1855
1856 If replica-preserve-commit-order is disabled, it does not call
1857 update_on_commit from this stack. The reason is as follows:
1858
1859 In the normal case of MYSQL_BIN_LOG::commit, where the transaction is
1860 going to be written to the binary log, it invokes
1861 MYSQL_BIN_LOG::ordered_commit, which updates the GTID state (the call
1862 gtid_state->update_commit_group(first) in process_commit_stage_queue).
1863 However, when MYSQL_BIN_LOG::commit is invoked from this stack, it is
1864 because the transaction is not going to be written to the binary log,
1865 and then MYSQL_BIN_LOG::commit has a special case that calls
1866 ha_commit_low directly, skipping ordered_commit. Therefore, the GTID
1867 state is not updated in this stack.
1868
1869 On the other hand, if replica-preserve-commit-order is enabled, the
1870 logic that orders commit carries out a subset of the binlog group
1871 commit from within ha_commit_low, and this includes updating the GTID
1872 state. In particular, there is the following call stack under
1873 ha_commit_low:
1874
1875 ha_commit_low ->
1876 Commit_order_manager::wait_and_finish ->
1877 Commit_order_manager::finish ->
1878 Commit_order_manager::flush_engine_and_signal_threads ->
1879 Gtid_state::update_commit_group
1880
1881 Therefore, it is necessary to call update_on_commit only in case we
1882 are not using replica-preserve-commit-order here.
1883 */
1884
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 gtid_state->update_on_commit(thd);
1885 }
1886 } else {
1887 /*
1888 If statement is supposed to be written to binlog, we write it
1889 to the binary log. Inserting into table and releasing
1890 ownership will be done in the binlog commit handler.
1891 */
1892
1893 /*
1894 thd->cache_mngr may be uninitialized if the first transaction
1895 executed by the client is empty.
1896 */
1897
2/4
✓ Branch 0 taken 50455 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 50455 times.
 50457 if (thd->binlog_setup_trx_data()) return 1;
1898
1/2
✓ Branch 0 taken 50455 times.
✗ Branch 1 not taken.
 50455 binlog_cache_data *cache_data = &thd_get_cache_mngr(thd)->trx_cache;
1899
1900 // Generate BEGIN event
1901 Query_log_event qinfo(thd, STRING_WITH_LEN("BEGIN"), true, false, true, 0,
1902
1/2
✓ Branch 0 taken 50455 times.
✗ Branch 1 not taken.
 50455 true);
1903
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50455 times.
 50455 assert(!qinfo.is_using_immediate_logging());
1904
1905 /*
1906 Write BEGIN event and then commit (which will generate commit
1907 event and Gtid_log_event)
1908 */
1909
3/8
✓ Branch 0 taken 50455 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50455 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 50455 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 50455 DBUG_PRINT("debug", ("Writing to trx_cache"));
1910
7/10
✓ Branch 0 taken 50455 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50455 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 50455 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 50453 times.
✓ Branch 8 taken 2 times.
✓ Branch 9 taken 50453 times.
 50455 if (cache_data->write_event(&qinfo) || mysql_bin_log.commit(thd, true))
1911 2 return 1;
1912
2/2
✓ Branch 0 taken 50453 times.
✓ Branch 1 taken 2 times.
 50455 }
1913
2/2
✓ Branch 0 taken 1588332 times.
✓ Branch 1 taken 65807 times.
 1654139 } else if (thd->owned_gtid.sidno == THD::OWNED_SIDNO_ANONYMOUS ||
1914 /*
1915 A transaction with an empty owned gtid should call
1916 end_gtid_violating_transaction(...) to clear the
1917 flag thd->has_gtid_consistency_violatoin in case
1918 it is set. It missed the clear in ordered_commit,
1919 because its binlog transaction cache is empty.
1920 */
1921
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1588395 times.
 1588332 thd->has_gtid_consistency_violation)
1922
1923 {
1924
1/2
✓ Branch 0 taken 65812 times.
✗ Branch 1 not taken.
 65744 gtid_state->update_on_commit(thd);
1925
4/4
✓ Branch 0 taken 6548 times.
✓ Branch 1 taken 1581847 times.
✓ Branch 2 taken 6548 times.
✓ Branch 3 taken 1581847 times.
 1594943 } else if (thd->variables.gtid_next.type == ASSIGNED_GTID &&
1926
2/4
✓ Branch 0 taken 6548 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6548 times.
✗ Branch 3 not taken.
 6548 thd->owned_gtid_is_empty()) {
1927
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6548 times.
 6548 assert(thd->has_gtid_consistency_violation == false);
1928
1/2
✓ Branch 0 taken 6574 times.
✗ Branch 1 not taken.
 6548 gtid_state->update_on_commit(thd);
1929 }
1930
1931 1704710 return 0;
1932 1704712 }
1933
1934 77 bool MYSQL_BIN_LOG::reencrypt_logs() {
1935
1/2
✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
 77 DBUG_TRACE;
1936
1937
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77 times.
 77 if (!is_open()) return false;
1938
1939 77 std::string error_message;
1940 /* Gather the set of files to be accessed. */
1941 77 list<string> filename_list;
1942 77 LOG_INFO linfo;
1943 77 int error = 0;
1944 77 list<string>::reverse_iterator rit;
1945
1946 /* Read binary/relay log file names from index file. */
1947
1/2
✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
 77 mysql_mutex_lock(&LOCK_index);
1948
3/4
✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
✓ Branch 3 taken 77 times.
 1434 for (error = find_log_pos(&linfo, nullptr, false); !error;
1949 1357 error = find_next_log(&linfo, false)) {
1950
3/6
✓ Branch 0 taken 1357 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1357 times.
✗ Branch 5 not taken.
 1357 filename_list.push_back(string(linfo.log_file_name));
1951 }
1952
1/2
✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
 77 mysql_mutex_unlock(&LOCK_index);
1953
3/4
✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 75 times.
 154 if (error != LOG_INFO_EOF ||
1954
3/4
✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 75 times.
 77 DBUG_EVALUATE_IF("fail_to_open_index_file", true, false)) {
1955
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 error_message.assign("I/O error reading index file '");
1956
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 error_message.append(index_file_name);
1957
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 error_message.append("'");
1958 2 goto err;
1959 }
1960
1961 75 rit = filename_list.rbegin();
1962 /* Skip the last binary/relay log. */
1963
3/6
✓ Branch 0 taken 75 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 75 times.
✗ Branch 5 not taken.
 75 if (rit != filename_list.rend()) rit++;
1964 /* Iterate backwards through binary/relay logs. */
1965
3/4
✓ Branch 0 taken 1226 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1162 times.
✓ Branch 3 taken 64 times.
 1226 while (rit != filename_list.rend()) {
1966
1/2
✓ Branch 0 taken 1162 times.
✗ Branch 1 not taken.
 1162 const char *filename = rit->c_str();
1967
4/6
✓ Branch 0 taken 1162 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1161 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 1162 DBUG_EXECUTE_IF("purge_logs_during_reencryption", {
1968 purge_logs(filename, true, true /*need_lock_index=true*/,
1969 true /*need_update_threads=true*/, nullptr, false);
1970 });
1971 1162 MUTEX_LOCK(lock, &LOCK_index);
1972 std::unique_ptr<Binlog_ofile> ofile(
1973
1/2
✓ Branch 0 taken 1162 times.
✗ Branch 1 not taken.
 1162 Binlog_ofile::open_existing(key_file_binlog, filename, MYF(MY_WME)));
1974
1975 1162 if (ofile == nullptr ||
1976
7/8
✓ Branch 0 taken 1161 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1161 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1159 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 4 times.
✓ Branch 7 taken 1158 times.
 2321 DBUG_EVALUATE_IF("fail_to_open_log_file", true, false) ||
1977
3/4
✓ Branch 0 taken 1159 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1158 times.
 1159 DBUG_EVALUATE_IF("fail_to_read_index_file", true, false)) {
1978 /* If we can not open the log file, check if it exists in index file. */
1979
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 error = find_log_pos(&linfo, filename, false);
1980
3/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 3 times.
 4 DBUG_EXECUTE_IF("fail_to_read_index_file", error = LOG_INFO_IO;);
1981
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
 4 if (error == LOG_INFO_EOF) {
1982 /* If it does not exist in index file, re-encryption has finished. */
1983
5/10
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
 1 if (current_thd->is_error()) current_thd->clear_error();
1984 1 break;
1985
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 } else if (error == 0) {
1986 /* If it exists in index file, failed to open the log file. */
1987
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 error_message.assign("Failed to open log file '");
1988
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 error_message.append(filename);
1989
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 error_message.append("'");
1990 2 goto err;
1991
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 } else if (error == LOG_INFO_IO) {
1992 /* Failed to read index file. */
1993
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 error_message.assign("I/O error reading index file '");
1994
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 error_message.append(index_file_name);
1995
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 error_message.append("'");
1996 1 goto err;
1997 }
1998 }
1999
2000
2/2
✓ Branch 0 taken 1070 times.
✓ Branch 1 taken 88 times.
 1158 if (ofile->is_encrypted()) {
2001 std::unique_ptr<Truncatable_ostream> pipeline_head =
2002 1070 ofile->get_pipeline_head();
2003 std::unique_ptr<Binlog_encryption_ostream> binlog_encryption_ostream(
2004 1070 down_cast<Binlog_encryption_ostream *>(pipeline_head.release()));
2005
2006
1/2
✓ Branch 0 taken 1070 times.
✗ Branch 1 not taken.
 1070 auto ret_value = binlog_encryption_ostream->reencrypt();
2007
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1063 times.
 1070 if (ret_value.first) {
2008
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 error_message.assign("Failed to re-encrypt log file '");
2009
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 error_message.append(filename);
2010
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 error_message.append("': ");
2011
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 error_message.append(ret_value.second.c_str());
2012 7 goto err;
2013 }
2014
6/6
✓ Branch 0 taken 1063 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 1063 times.
✓ Branch 3 taken 7 times.
✓ Branch 4 taken 1063 times.
✓ Branch 5 taken 7 times.
 1084 }
2015
2016
1/2
✓ Branch 0 taken 1151 times.
✗ Branch 1 not taken.
 1151 rit++;
2017
6/6
✓ Branch 0 taken 1151 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 1151 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 10 times.
 1173 }
2018
2019 65 filename_list.clear();
2020
2021 65 return false;
2022
2023 12 err:
2024
3/10
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 12 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 12 if (current_thd->is_error()) current_thd->clear_error();
2025
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
 12 my_error(ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_REENCRYPT_LOG, MYF(0),
2026 error_message.c_str());
2027 12 filename_list.clear();
2028
2029 12 return true;
2030 77 }
2031
2032 5927339 bool binlog_cache_data::compress(THD *thd) {
2033
1/2
✓ Branch 0 taken 5927698 times.
✗ Branch 1 not taken.
 5927339 DBUG_TRACE;
2034 5927698 auto error{false};
2035 5927698 auto ctype{binary_log::transaction::compression::type::NONE};
2036
1/2
✓ Branch 0 taken 5927650 times.
✗ Branch 1 not taken.
 5927698 auto uncompressed_size{m_cache.length()};
2037 5927650 auto size{uncompressed_size};
2038 5927650 auto &cctx{thd->rpl_thd_ctx.transaction_compression_ctx()};
2039 5927447 binary_log::transaction::compression::Compressor *compressor{nullptr};
2040
2041 // no compression enabled (ctype == NONE at this point)
2042
2/2
✓ Branch 0 taken 5927346 times.
✓ Branch 1 taken 101 times.
 5927447 if (thd->variables.binlog_trx_compression == false) goto end;
2043
2044 // do not compress if there are incident events
2045
3/4
✓ Branch 0 taken 165 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 163 times.
 101 DBUG_EXECUTE_IF("binlog_compression_inject_incident", set_incident(););
2046
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 163 times.
 165 if (has_incident()) goto end;
2047
2048 // do not compress if there are non-transactional changes
2049 163 if (thd->get_transaction()->has_modified_non_trans_table(
2050
6/6
✓ Branch 0 taken 156 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 155 times.
✓ Branch 4 taken 8 times.
✓ Branch 5 taken 155 times.
 319 Transaction_ctx::STMT) ||
2051 156 thd->get_transaction()->has_modified_non_trans_table(
2052 Transaction_ctx::SESSION))
2053 8 goto end;
2054
2055 // do not compress if has SBR
2056
2/2
✓ Branch 0 taken 95 times.
✓ Branch 1 taken 60 times.
 155 if (may_have_sbr_stmts()) goto end;
2057
2058 // Unable to get a reference to a compressor, fallback to
2059 // non compressed
2060
2/4
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 60 times.
 60 if ((compressor = cctx.get_compressor(thd)) == nullptr) goto end;
2061
2062 // compression is enabled and all pre-conditions checked.
2063 // now compress
2064 else {
2065 60 std::size_t old_capacity{0};
2066 60 unsigned char *buffer{nullptr};
2067 60 unsigned char *old_buffer{nullptr};
2068
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
 60 Transaction_payload_log_event tple{thd};
2069
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
 60 Compressed_ostream stream;
2070 60 PSI_stage_info old_stage;
2071
2072 // set the thread stage to compressing transaction
2073
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
 60 thd->enter_stage(&stage_binlog_transaction_compress, &old_stage, __func__,
2074 __FILE__, __LINE__);
2075 // do we have enough compression buffer ? If not swap with a larger one
2076
2/4
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✗ Branch 3 not taken.
 60 std::tie(buffer, std::ignore, old_capacity) = compressor->get_buffer();
2077
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 28 times.
 60 if (old_capacity < size) {
2078 32 old_buffer = buffer;
2079 32 auto new_buffer = (unsigned char *)malloc(size);
2080
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 if (new_buffer)
2081
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 compressor->set_buffer(new_buffer, size);
2082 else {
2083 /* purecov: begin inspected */
2084 // OOM
2085 ✗ error = true;
2086 ✗ goto compression_end;
2087 /* purecov: end */
2088 }
2089 }
2090
2091
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
 60 ctype = compressor->compression_type_code();
2092
2093
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
 60 compressor->open();
2094
2095 // inject the compressor in the output stream
2096
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
 60 stream.set_compressor(compressor);
2097
2098 // FIXME: innefficient, we should not copy caches around
2099 // This should be fixed when we revamp the capture
2100 // cache handling (and make this more geared towards
2101 // possible enhancements, such as streaming the changes)
2102 // Also, if the cache actually spills to disk, this may
2103 // the impact may be amplified, since reiniting the
2104 // causes a flush to disk
2105
2/4
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 60 times.
 60 if ((error = m_cache.copy_to(&stream))) goto compression_end;
2106
2107
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
 60 compressor->close();
2108
2109
2/4
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 60 times.
 60 if ((error = m_cache.truncate(0))) goto compression_end;
2110 // Since we deleted all events from the cache, we also need to
2111 // reset event_counter.
2112 60 event_counter = 0;
2113
2114 // fill in the new transport event
2115
2/4
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✗ Branch 3 not taken.
 60 std::tie(buffer, size, std::ignore) = compressor->get_buffer();
2116 60 tple.set_payload((const char *)buffer);
2117 60 tple.set_payload_size(size);
2118 60 tple.set_compression_type(ctype);
2119 60 tple.set_uncompressed_size(uncompressed_size);
2120
2121 // write back the new cache contents
2122
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
 60 error = write_event(&tple);
2123
2124 60 compression_end:
2125 // revert back to the default buffer, so that we don't overuse memory
2126
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 28 times.
 60 if (old_buffer) {
2127
2/4
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
✗ Branch 3 not taken.
 32 std::tie(buffer, std::ignore, std::ignore) = compressor->get_buffer();
2128
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 compressor->set_buffer(old_buffer, old_capacity);
2129 32 free(buffer);
2130 }
2131
2132 // revert the stage if needed
2133
2/4
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✗ Branch 3 not taken.
 60 if (old_stage.m_key != 0) THD_STAGE_INFO(thd, old_stage);
2134 60 }
2135
2136 5927511 end:
2137
2/2
✓ Branch 0 taken 5927340 times.
✓ Branch 1 taken 171 times.
 5927511 if (!error) {
2138 5927340 set_compression_type(ctype);
2139
1/2
✓ Branch 0 taken 5927517 times.
✗ Branch 1 not taken.
 5927359 set_compressed_size(m_cache.length());
2140 5927425 set_decompressed_size(uncompressed_size);
2141 }
2142 5927755 return error;
2143 5927686 }
2144
2145 /**
2146 This function finalizes the cache preparing for commit or rollback.
2147
2148 The function just writes all the necessary events to the cache but
2149 does not flush the data to the binary log file. That is the role of
2150 the binlog_cache_data::flush function.
2151
2152 @see binlog_cache_data::flush
2153
2154 @param thd The thread whose transaction should be flushed
2155 @param end_event The end event either commit/rollback
2156
2157 @return
2158 nonzero if an error pops up when flushing the cache.
2159 */
2160 5927087 int binlog_cache_data::finalize(THD *thd, Log_event *end_event) {
2161
1/2
✓ Branch 0 taken 5927621 times.
✗ Branch 1 not taken.
 5927087 DBUG_TRACE;
2162
2/4
✓ Branch 0 taken 5927631 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927639 times.
✗ Branch 3 not taken.
 5927621 if (!is_binlog_empty()) {
2163
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5927639 times.
 5927639 assert(!flags.finalized);
2164
2/4
✓ Branch 0 taken 5927084 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5927084 times.
 5927639 if (int error = flush_pending_event(thd)) return error;
2165
2/4
✓ Branch 0 taken 5927754 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5927754 times.
 5927084 if (int error = write_event(end_event)) return error;
2166
2/4
✓ Branch 0 taken 5927759 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5927759 times.
 5927754 if (int error = this->compress(thd)) return error;
2167
6/10
✓ Branch 0 taken 5927609 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927581 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 103 times.
✓ Branch 5 taken 5927478 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 103 times.
✓ Branch 8 taken 129 times.
✗ Branch 9 not taken.
 5927759 DBUG_PRINT("debug", ("flags.finalized: %s", YESNO(flags.finalized)));
2168 5927607 flags.finalized = true;
2169 }
2170 5927599 return 0;
2171 5927599 }
2172
2173 /**
2174 The method writes XA END query to XA-prepared transaction's cache
2175 and calls the "basic" finalize().
2176
2177 @return error code, 0 success
2178 */
2179
2180 634 int binlog_cache_data::finalize(THD *thd, Log_event *end_event, XID_STATE *xs) {
2181 634 int error = 0;
2182 char buf[XID::ser_buf_size];
2183 char query[sizeof("XA END") + 1 + sizeof(buf)];
2184 634 int qlen = sprintf(query, "XA END %s", xs->get_xid()->serialize(buf));
2185
1/2
✓ Branch 0 taken 634 times.
✗ Branch 1 not taken.
 634 Query_log_event qev(thd, query, qlen, true, false, true, 0);
2186
2187
2/4
✓ Branch 0 taken 634 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 634 times.
 634 if ((error = write_event(&qev))) return error;
2188
2189
1/2
✓ Branch 0 taken 634 times.
✗ Branch 1 not taken.
 634 return finalize(thd, end_event);
2190 634 }
2191
2192 /**
2193 Flush caches to the binary log.
2194
2195 If the cache is finalized, the cache will be flushed to the binary
2196 log file. If the cache is not finalized, nothing will be done.
2197
2198 If flushing fails for any reason, an error will be reported and the
2199 cache will be reset. Flushing can fail in two circumstances:
2200
2201 - It was not possible to write the cache to the file. In this case,
2202 it does not make sense to keep the cache.
2203
2204 - The cache was successfully written to disk but post-flush actions
2205 (such as binary log rotation) failed. In this case, the cache is
2206 already written to disk and there is no reason to keep it.
2207
2208 @see binlog_cache_data::finalize
2209 */
2210 11852832 int binlog_cache_data::flush(THD *thd, my_off_t *bytes_written,
2211 bool *wrote_xid) {
2212 /*
2213 Doing a commit or a rollback including non-transactional tables,
2214 i.e., ending a transaction where we might write the transaction
2215 cache to the binary log.
2216
2217 We can always end the statement when ending a transaction since
2218 transactions are not allowed inside stored functions. If they
2219 were, we would have to ensure that we're not ending a statement
2220 inside a stored function.
2221 */
2222
1/2
✓ Branch 0 taken 11852832 times.
✗ Branch 1 not taken.
 11852832 DBUG_TRACE;
2223
7/10
✓ Branch 0 taken 11852832 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11852832 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 205 times.
✓ Branch 5 taken 11852627 times.
✓ Branch 6 taken 103 times.
✓ Branch 7 taken 102 times.
✓ Branch 8 taken 205 times.
✗ Branch 9 not taken.
 11852832 DBUG_PRINT("debug", ("flags.finalized: %s", YESNO(flags.finalized)));
2224 11852832 int error = 0;
2225
2/2
✓ Branch 0 taken 5927064 times.
✓ Branch 1 taken 5925768 times.
 11852832 if (flags.finalized) {
2226
1/2
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
 5927064 my_off_t bytes_in_cache = m_cache.length();
2227 5927064 Transaction_ctx *trn_ctx = thd->get_transaction();
2228
2229
5/8
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927064 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 103 times.
✓ Branch 5 taken 5926961 times.
✓ Branch 6 taken 103 times.
✗ Branch 7 not taken.
 5927064 DBUG_PRINT("debug", ("bytes_in_cache: %llu", bytes_in_cache));
2230
2231
1/2
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
 5927064 trn_ctx->sequence_number = mysql_bin_log.m_dependency_tracker.step();
2232
2233 /*
2234 In case of two caches the transaction is split into two groups.
2235 The 2nd group is considered to be a successor of the 1st rather
2236 than to have a common commit parent with it.
2237 Notice that due to a simple method of detection that the current is
2238 the 2nd cache being flushed, the very first few transactions may be logged
2239 sequentially (a next one is tagged as if a preceding one is its
2240 commit parent).
2241 */
2242
2/2
✓ Branch 0 taken 67942 times.
✓ Branch 1 taken 5859122 times.
 5927064 if (trn_ctx->last_committed == SEQ_UNINIT)
2243 67942 trn_ctx->last_committed = trn_ctx->sequence_number - 1;
2244
2245 /*
2246 The GTID is written prior to flushing the statement cache, if
2247 the transaction has written to the statement cache; and prior to
2248 flushing the transaction cache if the transaction has written to
2249 the transaction cache. If GTIDs are enabled, then transactional
2250 and non-transactional updates cannot be mixed, so at most one of
2251 the caches can be non-empty, so just one GTID will be
2252 generated. If GTIDs are disabled, then no GTID is generated at
2253 all; if both the transactional cache and the statement cache are
2254 non-empty then we get two Anonymous_gtid_log_events, which is
2255 correct.
2256 */
2257
1/2
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
 5927064 Binlog_event_writer writer(mysql_bin_log.get_binlog_file(), thd);
2258
2259 /* The GTID ownership process might set the commit_error */
2260
1/2
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
 11854128 error = (thd->commit_error == THD::CE_FLUSH_ERROR ||
2261
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5927063 times.
 5927064 thd->commit_error == THD::CE_FLUSH_GNO_EXHAUSTED_ERROR);
2262
2263
5/6
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29940 times.
✓ Branch 3 taken 5897124 times.
✓ Branch 4 taken 9886 times.
✓ Branch 5 taken 20054 times.
 5927064 DBUG_EXECUTE_IF("simulate_binlog_flush_error", {
2264 if (rand() % 3 == 0) {
2265 thd->commit_error = THD::CE_FLUSH_ERROR;
2266 }
2267 };);
2268
2269
4/6
✓ Branch 0 taken 5927064 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 5927063 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 5927064 DBUG_EXECUTE_IF("fault_injection_reinit_io_cache_while_flushing_to_file",
2270 { DBUG_SET("+d,fault_injection_reinit_io_cache"); });
2271
2272
2/2
✓ Branch 0 taken 5927063 times.
✓ Branch 1 taken 1 times.
 5927064 if (!error)
2273
3/4
✓ Branch 0 taken 5927060 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 5927057 times.
 5927063 if ((error = mysql_bin_log.write_transaction(thd, this, &writer)))
2274 3 thd->commit_error = THD::CE_FLUSH_ERROR;
2275
2276
4/6
✓ Branch 0 taken 5927061 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 5927060 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 5927061 DBUG_EXECUTE_IF("fault_injection_reinit_io_cache_while_flushing_to_file",
2277 { DBUG_SET("-d,fault_injection_reinit_io_cache"); });
2278
2279
4/4
✓ Branch 0 taken 5385685 times.
✓ Branch 1 taken 541376 times.
✓ Branch 2 taken 5385682 times.
✓ Branch 3 taken 3 times.
 5927061 if (flags.with_xid && error == 0) *wrote_xid = true;
2280
2281 /*
2282 Reset have to be after the if above, since it clears the
2283 with_xid flag
2284 */
2285
1/2
✓ Branch 0 taken 5927061 times.
✗ Branch 1 not taken.
 5927061 reset();
2286
1/2
✓ Branch 0 taken 5927061 times.
✗ Branch 1 not taken.
 5927061 if (bytes_written) *bytes_written = bytes_in_cache;
2287 5927061 }
2288
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11852829 times.
 11852829 assert(!flags.finalized);
2289 11852829 return error;
2290 11852829 }
2291
2292 /**
2293 This function truncates the transactional cache upon committing or rolling
2294 back either a transaction or a statement.
2295
2296 @param thd The thread whose transaction should be flushed
2297 @param all @c true means truncate the transaction, otherwise the
2298 statement must be truncated.
2299
2300 @return
2301 nonzero if an error pops up when truncating the transactional cache.
2302 */
2303 8030 int binlog_trx_cache_data::truncate(THD *thd, bool all) {
2304
1/2
✓ Branch 0 taken 8031 times.
✗ Branch 1 not taken.
 8030 DBUG_TRACE;
2305 8031 int error = 0;
2306
2307
8/14
✓ Branch 0 taken 8031 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8031 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 8030 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 1 times.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
 8031 DBUG_PRINT("info",
2308 ("thd->options={ %s %s}, transaction: %s",
2309 FLAGSTR(thd->variables.option_bits, OPTION_NOT_AUTOCOMMIT),
2310 FLAGSTR(thd->variables.option_bits, OPTION_BEGIN),
2311 all ? "all" : "stmt"));
2312
2313
1/2
✓ Branch 0 taken 8030 times.
✗ Branch 1 not taken.
 8031 remove_pending_event();
2314
2315 /*
2316 If rolling back an entire transaction or a single statement not
2317 inside a transaction, we reset the transaction cache.
2318 Even though formally the atomic DDL statement may not end multi-statement
2319 transaction the cache needs full resetting as there must
2320 be no other data in it but belonging to the DDL.
2321 */
2322
3/4
✓ Branch 0 taken 8031 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4127 times.
✓ Branch 3 taken 3904 times.
 8030 if (ending_trans(thd, all)) {
2323
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4125 times.
 4127 if (has_incident()) {
2324 2 const char *err_msg =
2325 "Error happend while resetting the transaction "
2326 "cache for a rolled back transaction or a single "
2327 "statement not inside a transaction.";
2328
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 error = mysql_bin_log.write_incident(thd, true /*need_lock_log=true*/,
2329 err_msg);
2330 }
2331
1/2
✓ Branch 0 taken 4127 times.
✗ Branch 1 not taken.
 4127 reset();
2332 }
2333 /*
2334 If rolling back a statement in a transaction, we truncate the
2335 transaction cache to remove the statement.
2336 */
2337
2/2
✓ Branch 0 taken 732 times.
✓ Branch 1 taken 3171 times.
 3904 else if (get_prev_position() != MY_OFF_T_UNDEF)
2338
1/2
✓ Branch 0 taken 732 times.
✗ Branch 1 not taken.
 732 restore_prev_position();
2339
2340 8030 thd->clear_binlog_table_maps();
2341
2342 8031 return error;
2343 8030 }
2344
2345 5446711 inline enum xa_option_words get_xa_opt(THD *thd) {
2346 5446711 enum xa_option_words xa_opt = XA_NONE;
2347
2/2
✓ Branch 0 taken 1183 times.
✓ Branch 1 taken 5445528 times.
 5446711 switch (thd->lex->sql_command) {
2348 1183 case SQLCOM_XA_COMMIT:
2349 xa_opt =
2350 1183 static_cast<Sql_cmd_xa_commit *>(thd->lex->m_sql_cmd)->get_xa_opt();
2351 1183 break;
2352 5445528 default:
2353 5445528 break;
2354 }
2355
2356 5446711 return xa_opt;
2357 }
2358
2359 /**
2360 Predicate function yields true when XA transaction is
2361 being logged having a proper state ready for prepare or
2362 commit in one phase.
2363
2364 @param thd THD pointer of running transaction
2365 @return true When the being prepared transaction should be binlogged,
2366 false otherwise.
2367 */
2368
2369 50842059 inline bool is_loggable_xa_prepare(THD *thd) {
2370 /*
2371 simulate_commit_failure is doing a trick with XID_STATE while
2372 the ongoing transaction is not XA, and therefore to be errored out,
2373 asserted below. In that case because of the
2374 latter fact the function returns @c false.
2375 */
2376
1/8
✗ Branch 0 not taken.
✓ Branch 1 taken 50843301 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 50842059 DBUG_EXECUTE_IF("simulate_commit_failure", {
2377 XID_STATE *xs = thd->get_transaction()->xid_state();
2378 assert((thd->is_error() && xs->get_state() == XID_STATE::XA_IDLE) ||
2379 xs->get_state() == XID_STATE::XA_NOTR);
2380 });
2381
2382
3/4
✓ Branch 0 taken 50843776 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2464 times.
✓ Branch 3 taken 50841721 times.
 50843301 return DBUG_EVALUATE_IF(
2383 "simulate_commit_failure", false,
2384 thd->get_transaction()->xid_state()->has_state(XID_STATE::XA_IDLE));
2385 }
2386
2387 11110320 static int binlog_prepare(handlerton *, THD *thd, bool all) {
2388
1/2
✓ Branch 0 taken 11110947 times.
✗ Branch 1 not taken.
 11110320 DBUG_TRACE;
2389
2/2
✓ Branch 0 taken 10610746 times.
✓ Branch 1 taken 500201 times.
 11110947 if (!all) {
2390
1/2
✓ Branch 0 taken 10610785 times.
✗ Branch 1 not taken.
 10610746 thd->get_transaction()->store_commit_parent(
2391 mysql_bin_log.m_dependency_tracker.get_max_committed_timestamp());
2392 }
2393 11111020 return 0;
2394 11110649 }
2395
2396 527 static int binlog_set_prepared_in_tc(handlerton *, THD *) { return 0; }
2397
2398 /**
2399 Logging XA commit/rollback of a prepared transaction in the case
2400 it was disconnected and resumed (recovered), or executed by a slave applier.
2401
2402 @param thd THD handle
2403 @param xid a pointer to XID object
2404 @param commit when @c true XA-COMMIT is logged, otherwise XA-ROLLBACK
2405
2406 @return error code, 0 success
2407 */
2408 1320 int MYSQL_BIN_LOG::write_xa_to_cache(THD *thd) {
2409
3/4
✓ Branch 0 taken 238 times.
✓ Branch 1 taken 1082 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 238 times.
 1320 assert(thd->lex->sql_command == SQLCOM_XA_COMMIT ||
2410 thd->lex->sql_command == SQLCOM_XA_ROLLBACK);
2411
2412
3/4
✓ Branch 0 taken 1320 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 194 times.
✓ Branch 3 taken 1126 times.
 1320 if (get_xa_opt(thd) == XA_ONE_PHASE) return 0;
2413
2414 1126 auto xid_state = thd->get_transaction()->xid_state();
2415
2/2
✓ Branch 0 taken 569 times.
✓ Branch 1 taken 557 times.
 1126 if (!xid_state->is_binlogged())
2416 569 return 0; // nothing was really logged at prepare
2417
2418
7/10
✓ Branch 0 taken 557 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 555 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✓ Branch 9 taken 555 times.
 557 if (thd->is_error() && DBUG_EVALUATE_IF("simulate_xa_rm_error", 0, 1))
2419 2 return 0; // don't binlog if there are some errors.
2420
2421 555 auto xid_to_write = xid_state->get_xid();
2422
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 555 times.
 555 assert(xid_to_write != nullptr);
2423
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 555 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 555 assert(!xid_to_write->is_null() ||
2424 !(thd->variables.option_bits & OPTION_BIN_LOG));
2425
2426
1/2
✓ Branch 0 taken 555 times.
✗ Branch 1 not taken.
 555 std::ostringstream oss;
2427 oss << "XA "
2428 555 << (thd->lex->sql_command == SQLCOM_XA_COMMIT ? "COMMIT" : "ROLLBACK")
2429
7/12
✓ Branch 0 taken 555 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 410 times.
✓ Branch 3 taken 145 times.
✓ Branch 4 taken 555 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 555 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 555 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 555 times.
✗ Branch 11 not taken.
 555 << " " << *xid_to_write << std::flush;
2430
1/2
✓ Branch 0 taken 555 times.
✗ Branch 1 not taken.
 555 auto query = oss.str();
2431 555 Query_log_event qinfo(thd, query.data(), query.length(), false, true, true, 0,
2432
1/2
✓ Branch 0 taken 555 times.
✗ Branch 1 not taken.
 1110 false);
2433
1/2
✓ Branch 0 taken 555 times.
✗ Branch 1 not taken.
 555 return this->write_event(&qinfo);
2434 555 }
2435
2436 112 static int binlog_start_consistent_snapshot(handlerton *hton, THD *thd) {
2437
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 DBUG_ENTER("binlog_start_consistent_snapshot");
2438
2439
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 int err = thd->binlog_setup_trx_data();
2440
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 112 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 112 if (err) DBUG_RETURN(err);
2441
2442
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
2443
2444 /* Server layer calls us with LOCK_log locked, so this is safe. */
2445
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 mysql_bin_log.raw_get_current_log(&cache_mngr->binlog_info);
2446
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 gtid_state->get_snapshot_gtid_executed(cache_mngr->snapshot_gtid_executed);
2447
2448
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 trans_register_ha(thd, true, hton, nullptr);
2449
2450
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 DBUG_RETURN(err);
2451 }
2452
2453 21 static int binlog_clone_consistent_snapshot(handlerton *hton, THD *thd,
2454 THD *from_thd) {
2455
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 DBUG_ENTER("binlog_start_consistent_snapshot");
2456
2457 const binlog_cache_mngr *from_cache_mngr =
2458 opt_bin_log
2459
2/4
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
 21 ? static_cast<binlog_cache_mngr *>(thd_get_cache_mngr(from_thd))
2460 21 : nullptr;
2461
2462
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
 21 if (from_cache_mngr == nullptr) {
2463 ✗ push_warning_printf(thd, Sql_condition::SL_WARNING, HA_ERR_UNSUPPORTED,
2464 "WITH CONSISTENT SNAPSHOT FROM SESSION was ignored for "
2465 "binary log, because the specified session does not "
2466 "have a consistent snapshot of binary log "
2467 "coordinates.");
2468 ✗ DBUG_RETURN(0);
2469 }
2470
2471
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 int err = thd->binlog_setup_trx_data();
2472
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 21 if (err) DBUG_RETURN(err);
2473
2474
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
2475
2476 21 const my_off_t pos = from_cache_mngr->binlog_info.pos;
2477 char log_file_name[FN_REFLEN];
2478
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 strmake(log_file_name, from_cache_mngr->binlog_info.log_file_name,
2479 sizeof(log_file_name) - 1);
2480
2481
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 mysql_mutex_lock(&thd->LOCK_thd_data);
2482
2483
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 cache_mngr->snapshot_gtid_executed = from_cache_mngr->snapshot_gtid_executed;
2484 21 cache_mngr->binlog_info.pos = pos;
2485
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 strmake(cache_mngr->binlog_info.log_file_name, log_file_name,
2486 sizeof(cache_mngr->binlog_info.log_file_name) - 1);
2487
2488
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 mysql_mutex_unlock(&thd->LOCK_thd_data);
2489
2490
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 trans_register_ha(thd, true, hton, nullptr);
2491
2492
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 DBUG_RETURN(err);
2493 }
2494
2495 /**
2496 When a fatal error occurs due to which binary logging becomes impossible and
2497 the user specified binlog_error_action= ABORT_SERVER the following function is
2498 invoked. This function pushes the appropriate error message to client and logs
2499 the same to server error log and then aborts the server.
2500
2501 @param err_string Error string which specifies the exact error
2502 message from the caller.
2503 */
2504 ✗ static void exec_binlog_error_action_abort(const char *err_string) {
2505 ✗ THD *thd = current_thd;
2506 /*
2507 When the code enters here it means that there was an error at higher layer
2508 and my_error function could have been invoked to let the client know what
2509 went wrong during the execution.
2510
2511 But these errors will not let the client know that the server is going to
2512 abort. Even if we add an additional my_error function call at this point
2513 client will be able to see only the first error message that was set
2514 during the very first invocation of my_error function call.
2515
2516 The advantage of having multiple my_error function calls are visible when
2517 the server is up and running and user issues SHOW WARNINGS or SHOW ERROR
2518 calls. In this special scenario server will be immediately aborted and
2519 user will not be able execute the above SHOW commands.
2520
2521 Hence we clear the previous errors and push one critical error message to
2522 clients.
2523 */
2524 ✗ if (thd) {
2525 ✗ if (thd->is_error()) thd->clear_error();
2526 /*
2527 Send error to both client and to the server error log.
2528 */
2529 ✗ my_error(ER_BINLOG_LOGGING_IMPOSSIBLE, MYF(ME_FATALERROR), err_string);
2530 }
2531
2532 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_LOGGING_NOT_POSSIBLE, err_string);
2533 ✗ flush_error_log_messages();
2534
2535 ✗ if (thd) thd->send_statement_status();
2536 ✗ my_abort();
2537 }
2538
2539 /**
2540 This function is called once after each statement.
2541
2542 @todo This function is currently not used any more and will
2543 eventually be eliminated. The real commit job is done in the
2544 MYSQL_BIN_LOG::commit function.
2545
2546 @see MYSQL_BIN_LOG::commit
2547
2548 @see handlerton::commit
2549 */
2550 11585739 static int binlog_commit(handlerton *, THD *, bool) {
2551
1/2
✓ Branch 0 taken 11585870 times.
✗ Branch 1 not taken.
 11585739 DBUG_TRACE;
2552 /*
2553 Nothing to do (any more) on commit.
2554 */
2555 11585888 return 0;
2556 11585870 }
2557
2558 /**
2559 This function is called when a transaction or a statement is rolled back.
2560
2561 @internal It is necessary to execute a rollback here if the
2562 transaction was rolled back because of executing a ROLLBACK TO
2563 SAVEPOINT command, but it is not used for normal rollback since
2564 MYSQL_BIN_LOG::rollback is called in that case.
2565
2566 @todo Refactor code to introduce a <code>MYSQL_BIN_LOG::rollback(THD
2567 *thd, SAVEPOINT *sv)</code> function in @c TC_LOG and have that
2568 function execute the necessary work to rollback to a savepoint.
2569
2570 @param thd The client thread that executes the transaction.
2571 @param all This is @c true if this is a real transaction rollback, and
2572 @false otherwise.
2573
2574 @see handlerton::rollback
2575 */
2576 6705 static int binlog_rollback(handlerton *, THD *thd, bool all) {
2577
1/2
✓ Branch 0 taken 6705 times.
✗ Branch 1 not taken.
 6705 DBUG_TRACE;
2578 6705 int error = 0;
2579
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 6673 times.
 6705 if (thd->lex->sql_command == SQLCOM_ROLLBACK_TO_SAVEPOINT)
2580
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 error = mysql_bin_log.rollback(thd, all);
2581 6705 return error;
2582 6705 }
2583
2584 /**
2585 Write a rollback record of the transaction to the binary log.
2586
2587 For binary log group commit, the rollback is separated into three
2588 parts:
2589
2590 1. First part consists of filling the necessary caches and
2591 finalizing them (if they need to be finalized). After a cache is
2592 finalized, nothing can be added to the cache.
2593
2594 2. Second part execute an ordered flush and commit. This will be
2595 done using the group commit functionality in @c ordered_commit.
2596
2597 Since we roll back the transaction early, we call @c
2598 ordered_commit with the @c skip_commit flag set. The @c
2599 ha_commit_low call inside @c ordered_commit will then not be
2600 called.
2601
2602 3. Third part checks any errors resulting from the flush and handles
2603 them appropriately.
2604
2605 @see MYSQL_BIN_LOG::ordered_commit
2606 @see ha_commit_low
2607 @see ha_rollback_low
2608
2609 @param thd Session to commit
2610 @param all This is @c true if this is a real transaction rollback, and
2611 @c false otherwise.
2612
2613 @return Error code, or zero if there were no error.
2614 */
2615
2616 2017694 int MYSQL_BIN_LOG::rollback(THD *thd, bool all) {
2617 2017694 int error = 0;
2618 2017694 bool stuff_logged = false;
2619
1/2
✓ Branch 0 taken 2018411 times.
✗ Branch 1 not taken.
 2017694 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd);
2620 2018411 bool is_empty = false;
2621
2622
1/2
✓ Branch 0 taken 2018639 times.
✗ Branch 1 not taken.
 2018411 DBUG_TRACE;
2623
10/14
✓ Branch 0 taken 2018554 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2018552 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2018547 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✓ Branch 9 taken 1 times.
✓ Branch 10 taken 2 times.
✓ Branch 11 taken 3 times.
✓ Branch 12 taken 5 times.
✗ Branch 13 not taken.
 2018639 DBUG_PRINT("enter",
2624 ("all: %s, cache_mngr: 0x%llx, thd->is_error: %s", YESNO(all),
2625 (ulonglong)cache_mngr, YESNO(thd->is_error())));
2626 /*
2627 Defer XA-transaction rollback until its XA-rollback event is recorded.
2628 When we are executing a ROLLBACK TO SAVEPOINT, we
2629 should only clear the caches since this function is called as part
2630 of the engine rollback.
2631 In other cases we roll back the transaction in the engines early
2632 since this will release locks and allow other transactions to
2633 start executing.
2634 */
2635
3/4
✓ Branch 0 taken 2017903 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 238 times.
✓ Branch 3 taken 2017665 times.
 2018552 if (is_xa_rollback(thd)) {
2636 238 auto xs = thd->get_transaction()->xid_state();
2637
2638
7/10
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 211 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 25 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
 238 assert(all || !xs->is_binlogged() ||
2639 (!xs->is_detached() && thd->is_error()));
2640
2641 238 is_empty = !xs->is_binlogged();
2642
2643
2/4
✓ Branch 0 taken 238 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 238 times.
 238 if ((error = this->write_xa_to_cache(thd)) != 0) goto end;
2644
2645
1/2
✓ Branch 0 taken 238 times.
✗ Branch 1 not taken.
 238 cache_mngr = thd_get_cache_mngr(thd);
2646
2/2
✓ Branch 0 taken 2017424 times.
✓ Branch 1 taken 241 times.
 2017665 } else if (thd->lex->sql_command != SQLCOM_ROLLBACK_TO_SAVEPOINT) {
2647 /*
2648 Reset binlog_snapshot_% variables for the current connection so that the
2649 current coordinates are shown after committing a consistent snapshot
2650 transaction.
2651 */
2652
2/2
✓ Branch 0 taken 210410 times.
✓ Branch 1 taken 1807014 times.
 2017424 if (cache_mngr != nullptr) {
2653
1/2
✓ Branch 0 taken 210452 times.
✗ Branch 1 not taken.
 210410 mysql_mutex_lock(&thd->LOCK_thd_data);
2654 210452 cache_mngr->drop_consistent_snapshot();
2655
1/2
✓ Branch 0 taken 210490 times.
✗ Branch 1 not taken.
 210459 mysql_mutex_unlock(&thd->LOCK_thd_data);
2656 }
2657
2/4
✓ Branch 0 taken 2017343 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2017343 times.
 2017504 if ((error = trx_coordinator::rollback_in_engines(thd, all))) goto end;
2658 }
2659
2660 /*
2661 If there is no cache manager, or if there is nothing in the
2662 caches, there are no caches to roll back, so we're trivially done
2663 unless XA-ROLLBACK that yet to run rollback_low().
2664 */
2665
7/8
✓ Branch 0 taken 210689 times.
✓ Branch 1 taken 1807133 times.
✓ Branch 2 taken 210763 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 202063 times.
✓ Branch 5 taken 8700 times.
✓ Branch 6 taken 2009154 times.
✓ Branch 7 taken 8742 times.
 2017822 if (cache_mngr == nullptr || cache_mngr->is_binlog_empty()) {
2666 2009154 goto end;
2667 }
2668
2669
8/14
✓ Branch 0 taken 8700 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8700 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 8699 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 1 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 1 times.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
 8742 DBUG_PRINT("debug", ("all.cannot_safely_rollback(): %s, trx_cache_empty: %s",
2670 YESNO(thd->get_transaction()->cannot_safely_rollback(
2671 Transaction_ctx::SESSION)),
2672 YESNO(cache_mngr->trx_cache.is_binlog_empty())));
2673
8/14
✓ Branch 0 taken 8700 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8700 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 8699 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 1 times.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
 8700 DBUG_PRINT("debug",
2674 ("stmt.cannot_safely_rollback(): %s, stmt_cache_empty: %s",
2675 YESNO(thd->get_transaction()->cannot_safely_rollback(
2676 Transaction_ctx::STMT)),
2677 YESNO(cache_mngr->stmt_cache.is_binlog_empty())));
2678
2679 /*
2680 If an incident event is set we do not flush the content of the statement
2681 cache because it may be corrupted.
2682 */
2683
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 8693 times.
 8700 if (cache_mngr->stmt_cache.has_incident()) {
2684 7 const char *err_msg =
2685 "The content of the statement cache is corrupted "
2686 "while writing a rollback record of the transaction "
2687 "to the binary log.";
2688
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 error = write_incident(thd, true /*need_lock_log=true*/, err_msg);
2689
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 cache_mngr->stmt_cache.reset();
2690
3/4
✓ Branch 0 taken 8693 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 838 times.
✓ Branch 3 taken 7855 times.
 8693 } else if (!cache_mngr->stmt_cache.is_binlog_empty()) {
2691 1703 if (thd->lex->sql_command == SQLCOM_CREATE_TABLE &&
2692
2/4
✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27 times.
✗ Branch 3 not taken.
 27 !thd->lex->query_block->field_list_is_empty() && /* With select */
2693
6/8
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 811 times.
✓ Branch 2 taken 27 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 27 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 27 times.
✓ Branch 7 taken 811 times.
 892 !(thd->lex->create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
2694 27 thd->is_current_stmt_binlog_format_row()) {
2695 /*
2696 In row based binlog format, we reset the binlog statement cache
2697 when rolling back a single statement 'CREATE...SELECT' transaction,
2698 since the 'CREATE TABLE' event was put in the binlog statement cache.
2699 */
2700
1/2
✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
 27 cache_mngr->stmt_cache.reset();
2701 } else {
2702
2/4
✓ Branch 0 taken 811 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 811 times.
 811 if ((error = cache_mngr->stmt_cache.finalize(thd))) goto end;
2703 811 stuff_logged = true;
2704 }
2705 }
2706
2707
3/4
✓ Branch 0 taken 8699 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4587 times.
✓ Branch 3 taken 4112 times.
 8700 if (ending_trans(thd, all)) {
2708
3/4
✓ Branch 0 taken 4587 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 482 times.
✓ Branch 3 taken 4105 times.
 4587 if (trans_cannot_safely_rollback(thd)) {
2709 482 auto xs = thd->get_transaction()->xid_state();
2710
1/2
✓ Branch 0 taken 482 times.
✗ Branch 1 not taken.
 482 std::string query{"ROLLBACK"};
2711
2712
2/4
✓ Branch 0 taken 482 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 482 times.
 482 if (is_xa_rollback(thd)) {
2713 /* this block is relevant only for not prepared yet and "local" xa trx
2714 */
2715 ✗ assert(
2716 thd->get_transaction()->xid_state()->has_state(XID_STATE::XA_IDLE));
2717
2718 ✗ std::ostringstream oss;
2719 ✗ oss << "XA ROLLBACK " << *xs->get_xid() << std::flush;
2720 ✗ query = oss.str();
2721 }
2722 /*
2723 If the transaction is being rolled back and contains changes that
2724 cannot be rolled back, the trx-cache's content is flushed.
2725 */
2726 482 Query_log_event end_evt(thd, query.data(), query.length(), true, false,
2727
1/2
✓ Branch 0 taken 482 times.
✗ Branch 1 not taken.
 964 true, 0, true);
2728 964 error = thd->lex->sql_command != SQLCOM_XA_ROLLBACK
2729
2/4
✓ Branch 0 taken 482 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 482 times.
✗ Branch 3 not taken.
 482 ? cache_mngr->trx_cache.finalize(thd, &end_evt)
2730 ✗ : cache_mngr->trx_cache.finalize(thd, &end_evt, xs);
2731 482 stuff_logged = true;
2732 482 } else {
2733 /*
2734 If the transaction is being rolled back and its changes can be
2735 rolled back, the trx-cache's content is truncated.
2736 */
2737
1/2
✓ Branch 0 taken 4105 times.
✗ Branch 1 not taken.
 4105 error = cache_mngr->trx_cache.truncate(thd, all);
2738
2739
4/6
✓ Branch 0 taken 4105 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 4103 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
 4105 DBUG_EXECUTE_IF("ensure_binlog_cache_is_reset", {
2740 /* Assert that binlog cache is reset at rollback time. */
2741 assert(binlog_cache_is_reset);
2742 binlog_cache_is_reset = false;
2743 };);
2744 }
2745 } else {
2746 /*
2747 If a statement is being rolled back, it is necessary to know
2748 exactly why a statement may not be safely rolled back as in
2749 some specific situations the trx-cache can be truncated.
2750
2751 If a temporary table is created or dropped, the trx-cache is not
2752 truncated. Note that if the stmt-cache is used, there is nothing
2753 to truncate in the trx-cache.
2754
2755 If a non-transactional table is updated and the binlog format is
2756 statement, the trx-cache is not truncated. The trx-cache is used
2757 when the direct option is off and a transactional table has been
2758 updated before the current statement in the context of the
2759 current transaction. Note that if the stmt-cache is used there is
2760 nothing to truncate in the trx-cache.
2761
2762 If other binlog formats are used, updates to non-transactional
2763 tables are written to the stmt-cache and trx-cache can be safely
2764 truncated, if necessary.
2765 */
2766
1/2
✓ Branch 0 taken 4113 times.
✗ Branch 1 not taken.
 8225 if (thd->get_transaction()->has_dropped_temp_table(Transaction_ctx::STMT) ||
2767
5/6
✓ Branch 0 taken 4112 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 632 times.
✓ Branch 3 taken 3480 times.
✓ Branch 4 taken 294 times.
✓ Branch 5 taken 3818 times.
 8856 thd->get_transaction()->has_created_temp_table(Transaction_ctx::STMT) ||
2768 4113 (thd->get_transaction()->has_modified_non_trans_table(
2769 632 Transaction_ctx::STMT) &&
2770
2/2
✓ Branch 0 taken 294 times.
✓ Branch 1 taken 338 times.
 632 thd->variables.binlog_format == BINLOG_FORMAT_STMT)) {
2771 /*
2772 If the statement is being rolled back and dropped or created a
2773 temporary table or modified a non-transactional table and the
2774 statement-based replication is in use, the statement's changes
2775 in the trx-cache are preserved.
2776 */
2777
1/2
✓ Branch 0 taken 294 times.
✗ Branch 1 not taken.
 294 cache_mngr->trx_cache.set_prev_position(MY_OFF_T_UNDEF);
2778 } else {
2779 /*
2780 Otherwise, the statement's changes in the trx-cache are
2781 truncated.
2782 */
2783
1/2
✓ Branch 0 taken 3819 times.
✗ Branch 1 not taken.
 3818 error = cache_mngr->trx_cache.truncate(thd, all);
2784 }
2785 }
2786
2/2
✓ Branch 0 taken 1293 times.
✓ Branch 1 taken 7407 times.
 8700 if (stuff_logged) {
2787 1293 Transaction_ctx *trn_ctx = thd->get_transaction();
2788
1/2
✓ Branch 0 taken 1293 times.
✗ Branch 1 not taken.
 1293 trn_ctx->store_commit_parent(
2789 m_dependency_tracker.get_max_committed_timestamp());
2790 }
2791
2792
5/8
✓ Branch 0 taken 8699 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8700 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 8699 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
 8700 DBUG_PRINT("debug", ("error: %d", error));
2793
3/4
✓ Branch 0 taken 8700 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1293 times.
✓ Branch 3 taken 7407 times.
 8700 if (error == 0 && stuff_logged) {
2794
2/4
✓ Branch 0 taken 1293 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1293 times.
✗ Branch 3 not taken.
 1293 CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_invoke_before_commit_hook");
2795
7/12
✓ Branch 0 taken 1293 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1275 times.
✓ Branch 3 taken 18 times.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 18 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 18 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 1293 times.
 1293 if (RUN_HOOK(
2796 transaction, before_commit,
2797 (thd, all, thd_get_cache_mngr(thd)->get_trx_cache(),
2798 thd_get_cache_mngr(thd)->get_stmt_cache(),
2799 max<my_off_t>(max_binlog_cache_size, max_binlog_stmt_cache_size),
2800 false))) {
2801 // Reset the thread OK status before changing the outcome.
2802 ✗ if (thd->get_stmt_da()->is_ok())
2803 ✗ thd->get_stmt_da()->reset_diagnostics_area();
2804 ✗ my_error(ER_RUN_HOOK_ERROR, MYF(0), "before_commit");
2805 ✗ return RESULT_ABORTED;
2806 }
2807 // XA rollback is always accepted.
2808
2/4
✓ Branch 0 taken 1293 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1293 times.
 1293 assert(!thd->get_transaction()
2809 ->get_rpl_transaction_ctx()
2810 ->is_transaction_rollback());
2811
2812
1/2
✓ Branch 0 taken 1290 times.
✗ Branch 1 not taken.
 1293 error = ordered_commit(thd, all, /* skip_commit */ true);
2813
2814 // Inform hook listeners that a XA ROLLBACK did commit, that
2815 // is, did log a transaction to the binary log.
2816
6/8
✓ Branch 0 taken 1290 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1290 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 142 times.
✓ Branch 5 taken 1148 times.
✓ Branch 6 taken 142 times.
✓ Branch 7 taken 1148 times.
 1290 if (!error && is_xa_rollback(thd))
2817
4/6
✓ Branch 0 taken 142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 125 times.
✓ Branch 4 taken 17 times.
✗ Branch 5 not taken.
 142 (void)RUN_HOOK(transaction, after_commit, (thd, all));
2818 }
2819
2820
3/4
✓ Branch 0 taken 8696 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8589 times.
✓ Branch 3 taken 107 times.
 8697 if (check_write_error(thd)) {
2821 /*
2822 We reach this point if the effect of a statement did not properly get into
2823 a cache and need to be rolled back.
2824 */
2825
1/2
✓ Branch 0 taken 107 times.
✗ Branch 1 not taken.
 107 error |= cache_mngr->trx_cache.truncate(thd, all);
2826 }
2827
2828 8589 end:
2829 // The caches may be empty if an `XA ROLLBACK` was issued just after `XA
2830 // END`. In that case, the BCG will not be invoked and we need to
2831 // rollback in SEs and finalize GTID state.
2832
9/10
✓ Branch 0 taken 2017444 times.
✓ Branch 1 taken 406 times.
✓ Branch 2 taken 2016215 times.
✓ Branch 3 taken 1229 times.
✓ Branch 4 taken 2016224 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 93 times.
✓ Branch 7 taken 2016131 times.
✓ Branch 8 taken 93 times.
✓ Branch 9 taken 2017766 times.
 2017850 if (!error && !stuff_logged && is_xa_rollback(thd)) {
2833
1/2
✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
 93 error = trx_coordinator::rollback_in_engines(thd, all);
2834
6/8
✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 93 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 66 times.
✓ Branch 5 taken 27 times.
✓ Branch 6 taken 66 times.
✓ Branch 7 taken 27 times.
 93 if (!error && !thd->is_error()) {
2835 /*
2836 XA-rollback ignores the gtid_state, if the transaciton
2837 is empty.
2838 */
2839
4/6
✓ Branch 0 taken 66 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 60 times.
✗ Branch 5 not taken.
 66 if (is_empty && !thd->slave_thread) gtid_state->update_on_rollback(thd);
2840 /*
2841 XA-rollback commits the new gtid_state, if transaction
2842 is not empty.
2843 */
2844 else {
2845
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 gtid_state->update_on_commit(thd);
2846 /*
2847 Inform hook listeners that a XA ROLLBACK did commit, that
2848 is, did log a transaction to the binary log.
2849 */
2850
2/6
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 6 (void)RUN_HOOK(transaction, after_commit, (thd, all));
2851 }
2852 }
2853 }
2854 /*
2855 When a statement errors out on auto-commit mode it is rollback
2856 implicitly, so the same should happen to its GTID.
2857 */
2858
2/2
✓ Branch 0 taken 2005085 times.
✓ Branch 1 taken 12374 times.
 2017859 if (!thd->in_active_multi_stmt_transaction())
2859
1/2
✓ Branch 0 taken 2006134 times.
✗ Branch 1 not taken.
 2005085 gtid_state->update_on_rollback(thd);
2860
2861 /*
2862 TODO: some errors are overwritten, which may cause problem,
2863 fix it later.
2864 */
2865
4/8
✓ Branch 0 taken 2018601 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2018593 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2018588 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 2018508 DBUG_PRINT("return", ("error: %d", error));
2866 2018502 return error;
2867 2018502 }
2868
2869 /**
2870 @note
2871 How do we handle this (unlikely but legal) case:
2872 @verbatim
2873 [transaction] + [update to non-trans table] + [rollback to savepoint] ?
2874 @endverbatim
2875 The problem occurs when a savepoint is before the update to the
2876 non-transactional table. Then when there's a rollback to the savepoint, if we
2877 simply truncate the binlog cache, we lose the part of the binlog cache where
2878 the update is. If we want to not lose it, we need to write the SAVEPOINT
2879 command and the ROLLBACK TO SAVEPOINT command to the binlog cache. The latter
2880 is easy: it's just write at the end of the binlog cache, but the former
2881 should be *inserted* to the place where the user called SAVEPOINT. The
2882 solution is that when the user calls SAVEPOINT, we write it to the binlog
2883 cache (so no need to later insert it). As transactions are never intermixed
2884 in the binary log (i.e. they are serialized), we won't have conflicts with
2885 savepoint names when using mysqlbinlog or in the slave SQL thread.
2886 Then when ROLLBACK TO SAVEPOINT is called, if we updated some
2887 non-transactional table, we don't truncate the binlog cache but instead write
2888 ROLLBACK TO SAVEPOINT to it; otherwise we truncate the binlog cache (which
2889 will chop the SAVEPOINT command from the binlog cache, which is good as in
2890 that case there is no need to have it in the binlog).
2891 */
2892
2893 15125 static int binlog_savepoint_set(handlerton *, THD *thd, void *sv) {
2894
1/2
✓ Branch 0 taken 15125 times.
✗ Branch 1 not taken.
 15125 DBUG_TRACE;
2895 15125 int error = 1;
2896
2897 15125 String log_query;
2898
2/4
✓ Branch 0 taken 15125 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15125 times.
 15125 if (log_query.append(STRING_WITH_LEN("SAVEPOINT ")))
2899 ✗ return error;
2900 else
2901 15125 append_identifier(thd, &log_query, thd->lex->ident.str,
2902
1/2
✓ Branch 0 taken 15125 times.
✗ Branch 1 not taken.
 15125 thd->lex->ident.length);
2903
2904
1/2
✓ Branch 0 taken 15125 times.
✗ Branch 1 not taken.
 15125 int errcode = query_error_code(thd, thd->killed == THD::NOT_KILLED);
2905
1/2
✓ Branch 0 taken 15125 times.
✗ Branch 1 not taken.
 15125 Query_log_event qinfo(thd, log_query.c_ptr_safe(), log_query.length(), true,
2906
1/2
✓ Branch 0 taken 15125 times.
✗ Branch 1 not taken.
 30250 false, true, errcode);
2907 /*
2908 We cannot record the position before writing the statement
2909 because a rollback to a savepoint (.e.g. consider it "S") would
2910 prevent the savepoint statement (i.e. "SAVEPOINT S") from being
2911 written to the binary log despite the fact that the server could
2912 still issue other rollback statements to the same savepoint (i.e.
2913 "S").
2914 Given that the savepoint is valid until the server releases it,
2915 ie, until the transaction commits or it is released explicitly,
2916 we need to log it anyway so that we don't have "ROLLBACK TO S"
2917 or "RELEASE S" without the preceding "SAVEPOINT S" in the binary
2918 log.
2919 */
2920
2/4
✓ Branch 0 taken 15125 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15125 times.
✗ Branch 3 not taken.
 15125 if (!(error = mysql_bin_log.write_event(&qinfo)))
2921
1/2
✓ Branch 0 taken 15125 times.
✗ Branch 1 not taken.
 15125 binlog_trans_log_savepos(thd, (my_off_t *)sv);
2922
2923 15125 return error;
2924 15125 }
2925
2926 7653 static int binlog_savepoint_rollback(handlerton *, THD *thd, void *sv) {
2927
1/2
✓ Branch 0 taken 7653 times.
✗ Branch 1 not taken.
 7653 DBUG_TRACE;
2928
1/2
✓ Branch 0 taken 7653 times.
✗ Branch 1 not taken.
 7653 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
2929 7653 my_off_t pos = *(my_off_t *)sv;
2930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7653 times.
 7653 assert(pos != ~(my_off_t)0);
2931
2932 /*
2933 Write ROLLBACK TO SAVEPOINT to the binlog cache if we have updated some
2934 non-transactional table. Otherwise, truncate the binlog cache starting
2935 from the SAVEPOINT command.
2936 */
2937
3/4
✓ Branch 0 taken 7653 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 7638 times.
 7653 if (trans_cannot_safely_rollback(thd)) {
2938 15 String log_query;
2939
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
 15 if (log_query.append(STRING_WITH_LEN("ROLLBACK TO ")))
2940 ✗ return 1;
2941 else {
2942 /*
2943 Before writing identifier to the binlog, make sure to
2944 quote the identifier properly so as to prevent any SQL
2945 injection on the slave.
2946 */
2947 15 append_identifier(thd, &log_query, thd->lex->ident.str,
2948
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 thd->lex->ident.length);
2949 }
2950
2951
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 int errcode = query_error_code(thd, thd->killed == THD::NOT_KILLED);
2952
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 Query_log_event qinfo(thd, log_query.c_ptr_safe(), log_query.length(), true,
2953
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 30 false, true, errcode);
2954
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 return mysql_bin_log.write_event(&qinfo);
2955 15 }
2956 // Otherwise, we truncate the cache
2957
1/2
✓ Branch 0 taken 7638 times.
✗ Branch 1 not taken.
 7638 cache_mngr->trx_cache.restore_savepoint(pos);
2958 /*
2959 When a SAVEPOINT is executed inside a stored function/trigger we force the
2960 pending event to be flushed with a STMT_END_F flag and clear the table maps
2961 as well to ensure that following DMLs will have a clean state to start
2962 with. ROLLBACK inside a stored routine has to finalize possibly existing
2963 current row-based pending event with cleaning up table maps. That ensures
2964 that following DMLs will have a clean state to start with.
2965 */
2966
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 7625 times.
 7638 if (thd->in_sub_stmt) thd->clear_binlog_table_maps();
2967 7638 return 0;
2968 7653 }
2969
2970 /**
2971 purge logs, master and slave sides both, related error code
2972 converter.
2973 Called from @c purge_error_message(), @c MYSQL_BIN_LOG::reset_logs()
2974
2975 @param res an error code as used by purging routines
2976
2977 @return the user level error code ER_*
2978 */
2979 148 static uint purge_log_get_error_code(int res) {
2980 148 uint errcode = 0;
2981
2982
4/11
✓ Branch 0 taken 131 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
 148 switch (res) {
2983 131 case 0:
2984 131 break;
2985 11 case LOG_INFO_EOF:
2986 11 errcode = ER_UNKNOWN_TARGET_BINLOG;
2987 11 break;
2988 3 case LOG_INFO_IO:
2989 3 errcode = ER_IO_ERR_LOG_INDEX_READ;
2990 3 break;
2991 ✗ case LOG_INFO_INVALID:
2992 ✗ errcode = ER_BINLOG_PURGE_PROHIBITED;
2993 ✗ break;
2994 ✗ case LOG_INFO_SEEK:
2995 ✗ errcode = ER_FSEEK_FAIL;
2996 ✗ break;
2997 ✗ case LOG_INFO_MEM:
2998 ✗ errcode = ER_OUT_OF_RESOURCES;
2999 ✗ break;
3000 3 case LOG_INFO_FATAL:
3001 3 errcode = ER_BINLOG_PURGE_FATAL_ERR;
3002 3 break;
3003 ✗ case LOG_INFO_IN_USE:
3004 ✗ errcode = ER_LOG_IN_USE;
3005 ✗ break;
3006 ✗ case LOG_INFO_EMFILE:
3007 ✗ errcode = ER_BINLOG_PURGE_EMFILE;
3008 ✗ break;
3009 ✗ case LOG_INFO_BACKUP_LOCK:
3010 ✗ errcode = ER_CANNOT_PURGE_BINLOG_WITH_BACKUP_LOCK;
3011 ✗ break;
3012 ✗ default:
3013 ✗ errcode = ER_LOG_PURGE_UNKNOWN_ERR;
3014 ✗ break;
3015 }
3016
3017 148 return errcode;
3018 }
3019
3020 /**
3021 Check whether binlog state allows to safely release MDL locks after
3022 rollback to savepoint.
3023
3024 @param thd The client thread that executes the transaction.
3025
3026 @return true - It is safe to release MDL locks.
3027 false - If it is not.
3028 */
3029 7622 static bool binlog_savepoint_rollback_can_release_mdl(handlerton *, THD *thd) {
3030
1/2
✓ Branch 0 taken 7622 times.
✗ Branch 1 not taken.
 7622 DBUG_TRACE;
3031 /**
3032 If we have not updated any non-transactional tables rollback
3033 to savepoint will simply truncate binlog cache starting from
3034 SAVEPOINT command. So it should be safe to release MDL acquired
3035 after SAVEPOINT command in this case.
3036 */
3037
1/2
✓ Branch 0 taken 7622 times.
✗ Branch 1 not taken.
 15244 return !trans_cannot_safely_rollback(thd);
3038 7622 }
3039
3040 /**
3041 Adjust log offset in the binary log file for all running slaves
3042 This class implements call back function for do_for_all_thd().
3043 It is called for each thd in thd list to adjust offset.
3044 */
3045 class Adjust_offset : public Do_THD_Impl {
3046 public:
3047 210 Adjust_offset(my_off_t value) : m_purge_offset(value) {}
3048 899 void operator()(THD *thd) override {
3049 LOG_INFO *linfo;
3050 899 mysql_mutex_lock(&thd->LOCK_thd_data);
3051
2/2
✓ Branch 0 taken 83 times.
✓ Branch 1 taken 816 times.
 899 if ((linfo = thd->current_linfo)) {
3052 /*
3053 Index file offset can be less that purge offset only if
3054 we just started reading the index file. In that case
3055 we have nothing to adjust.
3056 */
3057
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 81 times.
 83 if (linfo->index_file_offset < m_purge_offset)
3058 2 linfo->fatal = (linfo->index_file_offset != 0);
3059 else
3060 81 linfo->index_file_offset -= m_purge_offset;
3061 }
3062 899 mysql_mutex_unlock(&thd->LOCK_thd_data);
3063 899 }
3064
3065 private:
3066 my_off_t m_purge_offset;
3067 };
3068
3069 /*
3070 Adjust the position pointer in the binary log file for all running slaves.
3071
3072 SYNOPSIS
3073 adjust_linfo_offsets()
3074 purge_offset Number of bytes removed from start of log index file
3075
3076 NOTES
3077 - This is called when doing a PURGE when we delete lines from the
3078 index log file.
3079
3080 REQUIREMENTS
3081 - Before calling this function, we have to ensure that no threads are
3082 using any binary log file before purge_offset.
3083
3084 TODO
3085 - Inform the slave threads that they should sync the position
3086 in the binary log file with flush_relay_log_info.
3087 Now they sync is done for next read.
3088 */
3089 210 static void adjust_linfo_offsets(my_off_t purge_offset) {
3090 210 Adjust_offset adjust_offset(purge_offset);
3091
1/2
✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
 210 Global_THD_manager::get_instance()->do_for_all_thd(&adjust_offset);
3092 210 }
3093
3094 /**
3095 This class implements Call back function for do_for_all_thd().
3096 It is called for each thd in thd list to count
3097 threads using bin log file
3098 */
3099
3100 class Log_in_use : public Do_THD_Impl {
3101 public:
3102 15425 Log_in_use(const char *value) : m_log_name(value), m_count(0) {
3103 15425 m_log_name_len = strlen(m_log_name) + 1;
3104 15425 }
3105 166557 void operator()(THD *thd) override {
3106 LOG_INFO *linfo;
3107 166557 mysql_mutex_lock(&thd->LOCK_thd_data);
3108
2/2
✓ Branch 0 taken 263 times.
✓ Branch 1 taken 166294 times.
 166557 if ((linfo = thd->current_linfo)) {
3109
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 263 times.
 263 if (!strncmp(m_log_name, linfo->log_file_name, m_log_name_len)) {
3110 ✗ LogErr(WARNING_LEVEL, ER_BINLOG_FILE_BEING_READ_NOT_PURGED, m_log_name,
3111 thd->thread_id());
3112 ✗ m_count++;
3113 }
3114 }
3115 166557 mysql_mutex_unlock(&thd->LOCK_thd_data);
3116 166557 }
3117 15425 int get_count() { return m_count; }
3118
3119 private:
3120 const char *m_log_name;
3121 size_t m_log_name_len;
3122 int m_count;
3123 };
3124
3125 15425 static int log_in_use(const char *log_name) {
3126 15425 Log_in_use log_in_use(log_name);
3127 #ifndef NDEBUG
3128
3/4
✓ Branch 0 taken 15425 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15235 times.
✓ Branch 3 taken 190 times.
 15425 if (current_thd)
3129
3/6
✓ Branch 0 taken 15235 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15235 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15235 times.
✗ Branch 5 not taken.
 15235 DEBUG_SYNC(current_thd, "purge_logs_after_lock_index_before_thread_count");
3130 #endif
3131
1/2
✓ Branch 0 taken 15425 times.
✗ Branch 1 not taken.
 15425 Global_THD_manager::get_instance()->do_for_all_thd(&log_in_use);
3132 30850 return log_in_use.get_count();
3133 15425 }
3134
3135 139 static bool purge_error_message(THD *thd, int res) {
3136 uint errcode;
3137
3138
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 131 times.
 139 if ((errcode = purge_log_get_error_code(res)) != 0) {
3139 8 my_error(errcode, MYF(0));
3140 8 return true;
3141 }
3142 131 my_ok(thd);
3143 131 return false;
3144 }
3145
3146 275 bool is_transaction_empty(THD *thd) {
3147
1/2
✓ Branch 0 taken 275 times.
✗ Branch 1 not taken.
 275 DBUG_TRACE;
3148
1/2
✓ Branch 0 taken 275 times.
✗ Branch 1 not taken.
 275 int rw_ha_count = check_trx_rw_engines(thd, Transaction_ctx::SESSION);
3149
1/2
✓ Branch 0 taken 275 times.
✗ Branch 1 not taken.
 275 rw_ha_count += check_trx_rw_engines(thd, Transaction_ctx::STMT);
3150 275 return rw_ha_count == 0;
3151 275 }
3152
3153 550 int check_trx_rw_engines(THD *thd, Transaction_ctx::enum_trx_scope trx_scope) {
3154
1/2
✓ Branch 0 taken 550 times.
✗ Branch 1 not taken.
 550 DBUG_TRACE;
3155
3156 550 int rw_ha_count = 0;
3157
1/2
✓ Branch 0 taken 550 times.
✗ Branch 1 not taken.
 550 auto ha_list = thd->get_transaction()->ha_trx_info(trx_scope);
3158
3159
7/12
✓ Branch 0 taken 550 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 550 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 471 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 471 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1021 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 471 times.
✓ Branch 11 taken 550 times.
 1021 for (auto const &ha_info : ha_list) {
3160
2/4
✓ Branch 0 taken 471 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 471 times.
✗ Branch 3 not taken.
 471 if (ha_info.is_trx_read_write()) ++rw_ha_count;
3161 550 }
3162 550 return rw_ha_count;
3163 550 }
3164
3165 884 bool is_empty_transaction_in_binlog_cache(const THD *thd) {
3166
1/2
✓ Branch 0 taken 884 times.
✗ Branch 1 not taken.
 884 DBUG_TRACE;
3167
3168
1/2
✓ Branch 0 taken 884 times.
✗ Branch 1 not taken.
 884 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
3169
6/8
✓ Branch 0 taken 884 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 884 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10 times.
✓ Branch 5 taken 874 times.
✓ Branch 6 taken 10 times.
✓ Branch 7 taken 874 times.
 884 if (cache_mngr != nullptr && cache_mngr->has_empty_transaction()) {
3170 10 return true;
3171 }
3172
3173 874 return false;
3174 884 }
3175
3176 /**
3177 This function checks if a transactional table was updated by the
3178 current transaction.
3179
3180 @param thd The client thread that executed the current statement.
3181 @return
3182 @c true if a transactional table was updated, @c false otherwise.
3183 */
3184 32487457 bool trans_has_updated_trans_table(const THD *thd) {
3185 32487457 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
3186
3187
2/2
✓ Branch 0 taken 24891572 times.
✓ Branch 1 taken 7597393 times.
 32488965 return (cache_mngr ? !cache_mngr->trx_cache.is_binlog_empty() : 0);
3188 }
3189
3190 /**
3191 This function checks if a transactional table was updated by the
3192 current statement.
3193
3194 @param ha_list Registered storage engine handler list.
3195 @return
3196 @c true if a transactional table was updated, @c false otherwise.
3197 */
3198 6935810 bool stmt_has_updated_trans_table(Ha_trx_info_list const &ha_list) {
3199
7/12
✓ Branch 0 taken 6936166 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6936531 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12225708 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5696562 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 12632541 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 12225592 times.
✓ Branch 11 taken 406949 times.
 12632186 for (auto const &ha_info : ha_list) {
3200
7/8
✓ Branch 0 taken 12225746 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12220481 times.
✓ Branch 3 taken 5265 times.
✓ Branch 4 taken 6529444 times.
✓ Branch 5 taken 5691108 times.
✓ Branch 6 taken 6529441 times.
✓ Branch 7 taken 5696376 times.
 12225708 if (ha_info.is_trx_read_write() && ha_info.ht() != binlog_hton)
3201 6529441 return (true);
3202
4/4
✓ Branch 0 taken 407010 times.
✓ Branch 1 taken 6529412 times.
✓ Branch 2 taken 407150 times.
✓ Branch 3 taken 6529384 times.
 13465802 }
3203 407150 return (false);
3204 }
3205
3206 /**
3207 This function checks if a transaction, either a multi-statement
3208 or a single statement transaction is about to commit or not.
3209
3210 @param thd The client thread that executed the current statement.
3211 @param all Committing a transaction (i.e. true) or a statement
3212 (i.e. false).
3213 @return
3214 @c true if committing a transaction, otherwise @c false.
3215 */
3216 28636424 bool ending_trans(THD *thd, const bool all) {
3217
4/4
✓ Branch 0 taken 25046546 times.
✓ Branch 1 taken 3589878 times.
✓ Branch 2 taken 10338698 times.
✓ Branch 3 taken 14708157 times.
 28636424 return (all || ending_single_stmt_trans(thd, all));
3218 }
3219
3220 /**
3221 This function checks if a single statement transaction is about
3222 to commit or not.
3223
3224 @param thd The client thread that executed the current statement.
3225 @param all Committing a transaction (i.e. true) or a statement
3226 (i.e. false).
3227 @return
3228 @c true if committing a single statement transaction, otherwise
3229 @c false.
3230 */
3231 25046801 bool ending_single_stmt_trans(THD *thd, const bool all) {
3232
4/4
✓ Branch 0 taken 25046763 times.
✓ Branch 1 taken 38 times.
✓ Branch 2 taken 10338525 times.
✓ Branch 3 taken 14708241 times.
 25046801 return (!all && !thd->in_multi_stmt_transaction_mode());
3233 }
3234
3235 /**
3236 This function checks if a transaction cannot be rolled back safely.
3237
3238 @param thd The client thread that executed the current statement.
3239 @return
3240 @c true if cannot be safely rolled back, @c false otherwise.
3241 */
3242 19862 bool trans_cannot_safely_rollback(const THD *thd) {
3243 19862 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
3244
3245 19862 return cache_mngr->trx_cache.cannot_rollback();
3246 }
3247
3248 /**
3249 This function checks if current statement cannot be rollded back safely.
3250
3251 @param thd The client thread that executed the current statement.
3252 @return
3253 @c true if cannot be safely rolled back, @c false otherwise.
3254 */
3255 520098 bool stmt_cannot_safely_rollback(const THD *thd) {
3256 520098 return thd->get_transaction()->cannot_safely_rollback(Transaction_ctx::STMT);
3257 }
3258
3259 /**
3260 Execute a PURGE BINARY LOGS TO @<log@> command.
3261
3262 @param thd Pointer to THD object for the client thread executing the
3263 statement.
3264
3265 @param to_log Name of the last log to purge.
3266
3267 @retval false success
3268 @retval true failure
3269 */
3270 138 bool purge_source_logs_to_file(THD *thd, const char *to_log) {
3271 // first run the purge validations
3272
1/2
✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
 138 auto [is_invalid, invalid_error] = check_purge_conditions(mysql_bin_log);
3273
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 137 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 138 if (is_invalid) return purge_error_message(thd, invalid_error);
3274
3275 char search_file_name[FN_REFLEN];
3276 137 constexpr auto auto_purge{false};
3277 137 constexpr auto include_to_log{false};
3278 137 constexpr auto need_index_lock{true};
3279 137 constexpr auto need_update_threads{true};
3280
1/2
✓ Branch 0 taken 137 times.
✗ Branch 1 not taken.
 137 mysql_bin_log.make_log_name(search_file_name, to_log);
3281
1/2
✓ Branch 0 taken 119 times.
✗ Branch 1 not taken.
 137 auto purge_error = mysql_bin_log.purge_logs(
3282 search_file_name, include_to_log, need_index_lock, need_update_threads,
3283 nullptr, auto_purge);
3284
1/2
✓ Branch 0 taken 119 times.
✗ Branch 1 not taken.
 119 return purge_error_message(thd, purge_error);
3285 }
3286
3287 /**
3288 Execute a PURGE BINARY LOGS BEFORE @<date@> command.
3289
3290 @param thd Pointer to THD object for the client thread executing the
3291 statement.
3292
3293 @param purge_time Date before which logs should be purged.
3294
3295 @retval false success
3296 @retval true failure
3297 */
3298 19 bool purge_source_logs_before_date(THD *thd, time_t purge_time) {
3299 // first run the purge validations
3300 19 const auto [is_invalid, invalid_error] =
3301
1/2
✓ Branch 0 taken 19 times.
✗ Branch 1 not taken.
 19 check_purge_conditions(mysql_bin_log);
3302
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 19 if (is_invalid) return purge_error_message(thd, invalid_error);
3303
3304 // validations done, now purge
3305 18 constexpr auto auto_purge{false};
3306 auto purge_error =
3307
1/2
✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
 18 mysql_bin_log.purge_logs_before_date(purge_time, auto_purge);
3308
1/2
✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
 18 return purge_error_message(thd, purge_error);
3309 }
3310
3311 /**
3312 Check whether the instance is backup locked.
3313
3314 @retval 0 Instance is not backup locked
3315 @retval other Instance is backup locked or failure
3316 */
3317 8835 int check_instance_backup_locked() {
3318 8835 int res{0};
3319
3320 8835 auto is_instance_locked = is_instance_backup_locked(current_thd);
3321
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
✓ Branch 2 taken 8804 times.
✗ Branch 3 not taken.
 8835 switch (is_instance_locked) {
3322 ✗ case Is_instance_backup_locked_result::OOM:
3323 ✗ res = LOG_INFO_MEM;
3324 ✗ break;
3325 31 case Is_instance_backup_locked_result::LOCKED:
3326 31 res = LOG_INFO_BACKUP_LOCK;
3327 31 break;
3328 8804 case Is_instance_backup_locked_result::NOT_LOCKED:
3329 8804 break;
3330 }
3331
3332 8835 return res;
3333 }
3334
3335 /*
3336 Helper function to get the error code of the query to be binlogged.
3337 */
3338 92634 int query_error_code(const THD *thd, bool not_killed) {
3339 int error;
3340
3341
2/2
✓ Branch 0 taken 92617 times.
✓ Branch 1 taken 17 times.
 92634 if (not_killed) {
3342
2/2
✓ Branch 0 taken 885 times.
✓ Branch 1 taken 91732 times.
 92617 error = thd->is_error() ? thd->get_stmt_da()->mysql_errno() : 0;
3343
3344 /* thd->get_stmt_da()->sql_errno() might be ER_SERVER_SHUTDOWN or
3345 ER_QUERY_INTERRUPTED, So here we need to make sure that error
3346 is not set to these errors when specified not_killed by the
3347 caller.
3348 */
3349
2/4
✓ Branch 0 taken 92617 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 92617 times.
 92617 if (error == ER_SERVER_SHUTDOWN || error == ER_QUERY_INTERRUPTED) error = 0;
3350 } else
3351 17 error = thd->killed;
3352
3353 92634 return error;
3354 }
3355
3356 /**
3357 Copy content of 'from' file from offset to 'to' file.
3358
3359 - We do the copy outside of the IO_CACHE as the cache
3360 buffers would just make things slower and more complicated.
3361 In most cases the copy loop should only do one read.
3362
3363 @param from File to copy.
3364 @param to File to copy to.
3365 @param offset Offset in 'from' file.
3366
3367
3368 @retval
3369 0 ok
3370 @retval
3371 -1 error
3372 */
3373 108997 static bool copy_file(IO_CACHE *from, IO_CACHE *to, my_off_t offset) {
3374 int bytes_read;
3375 uchar io_buf[IO_SIZE * 2];
3376
1/2
✓ Branch 0 taken 108997 times.
✗ Branch 1 not taken.
 108997 DBUG_TRACE;
3377
3378
1/2
✓ Branch 0 taken 108997 times.
✗ Branch 1 not taken.
 108997 mysql_file_seek(from->file, offset, MY_SEEK_SET, MYF(0));
3379 while (true) {
3380
1/2
✓ Branch 0 taken 186923 times.
✗ Branch 1 not taken.
 186923 if ((bytes_read = (int)mysql_file_read(from->file, io_buf, sizeof(io_buf),
3381
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 186923 times.
 186923 MYF(MY_WME))) < 0)
3382 ✗ goto err;
3383
3/4
✓ Branch 0 taken 186923 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 186917 times.
 186923 if (DBUG_EVALUATE_IF("fault_injection_copy_part_file", 1, 0))
3384 6 bytes_read = bytes_read / 2;
3385
2/2
✓ Branch 0 taken 108996 times.
✓ Branch 1 taken 77927 times.
 186923 if (!bytes_read) break; // end of file
3386
3/4
✓ Branch 0 taken 77927 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 77926 times.
 77927 if (mysql_file_write(to->file, io_buf, bytes_read, MYF(MY_WME | MY_NABP)))
3387 1 goto err;
3388 }
3389
3390 108996 return false;
3391
3392 1 err:
3393 1 return true;
3394 108997 }
3395
3396 /**
3397 Load data's io cache specific hook to be executed
3398 before a chunk of data is being read into the cache's buffer
3399 The function instantiates and writes into the binlog
3400 replication events along LOAD DATA processing.
3401
3402 @param file pointer to io-cache
3403 @retval 0 success
3404 @retval 1 failure
3405 */
3406 155946 int log_loaded_block(IO_CACHE *file) {
3407
1/2
✓ Branch 0 taken 155946 times.
✗ Branch 1 not taken.
 155946 DBUG_TRACE;
3408 LOAD_FILE_INFO *lf_info;
3409 uint block_len;
3410 /* buffer contains position where we started last read */
3411 155946 uchar *buffer = (uchar *)my_b_get_buffer_start(file);
3412
1/2
✓ Branch 0 taken 155946 times.
✗ Branch 1 not taken.
 155946 uint max_event_size = current_thd->variables.max_allowed_packet;
3413 155946 lf_info = (LOAD_FILE_INFO *)file->arg;
3414
2/2
✓ Branch 0 taken 143520 times.
✓ Branch 1 taken 12426 times.
 155946 if (lf_info->thd->is_current_stmt_binlog_format_row()) return 0;
3415
6/6
✓ Branch 0 taken 4160 times.
✓ Branch 1 taken 8266 times.
✓ Branch 2 taken 4114 times.
✓ Branch 3 taken 46 times.
✓ Branch 4 taken 4114 times.
✓ Branch 5 taken 8312 times.
 16586 if (lf_info->last_pos_in_file != HA_POS_ERROR &&
3416 4160 lf_info->last_pos_in_file >= my_b_get_pos_in_file(file))
3417 4114 return 0;
3418
3419
2/2
✓ Branch 0 taken 4182 times.
✓ Branch 1 taken 8312 times.
 12494 for (block_len = (uint)(my_b_get_bytes_in_buffer(file)); block_len > 0;
3420 4182 buffer += min(block_len, max_event_size),
3421 4182 block_len -= min(block_len, max_event_size)) {
3422 4182 lf_info->last_pos_in_file = my_b_get_pos_in_file(file);
3423
2/2
✓ Branch 0 taken 49 times.
✓ Branch 1 taken 4133 times.
 4182 if (lf_info->logged_data_file) {
3424 98 Append_block_log_event a(lf_info->thd, lf_info->thd->db().str, buffer,
3425 49 min(block_len, max_event_size),
3426
1/2
✓ Branch 0 taken 49 times.
✗ Branch 1 not taken.
 49 lf_info->log_delayed);
3427
2/4
✓ Branch 0 taken 49 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 49 times.
 49 if (mysql_bin_log.write_event(&a)) return 1;
3428
1/2
✓ Branch 0 taken 49 times.
✗ Branch 1 not taken.
 49 } else {
3429 8266 Begin_load_query_log_event b(lf_info->thd, lf_info->thd->db().str, buffer,
3430 4133 min(block_len, max_event_size),
3431
1/2
✓ Branch 0 taken 4133 times.
✗ Branch 1 not taken.
 4133 lf_info->log_delayed);
3432
2/4
✓ Branch 0 taken 4133 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4133 times.
 4133 if (mysql_bin_log.write_event(&b)) return 1;
3433 4133 lf_info->logged_data_file = true;
3434
1/2
✓ Branch 0 taken 4133 times.
✗ Branch 1 not taken.
 4133 }
3435 }
3436 8312 return 0;
3437 155946 }
3438
3439 /* Helper function for SHOW BINLOG/RELAYLOG EVENTS */
3440 template <class BINLOG_FILE_READER>
3441 36192 bool show_binlog_events(THD *thd, MYSQL_BIN_LOG *binary_log) {
3442 36192 Protocol *protocol = thd->get_protocol();
3443 36192 List<Item> field_list;
3444 36192 std::string errmsg;
3445 36192 LOG_INFO linfo;
3446
3447
1/2
✓ Branch 0 taken 18096 times.
✗ Branch 1 not taken.
 36192 DBUG_TRACE;
3448
3449
3/4
✓ Branch 0 taken 1253 times.
✓ Branch 1 taken 16843 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1253 times.
 36192 assert(thd->lex->sql_command == SQLCOM_SHOW_BINLOG_EVENTS ||
3450 thd->lex->sql_command == SQLCOM_SHOW_RELAYLOG_EVENTS);
3451
3452
2/2
✓ Branch 0 taken 18090 times.
✓ Branch 1 taken 6 times.
 36192 if (binary_log->is_open()) {
3453 36180 LEX_MASTER_INFO *lex_mi = &thd->lex->mi;
3454 36180 Query_expression *unit = thd->lex->unit;
3455 ha_rows event_count, limit_start, limit_end;
3456 36180 my_off_t pos =
3457 36180 max<my_off_t>(BIN_LOG_HEADER_SIZE, lex_mi->pos); // user-friendly
3458 char search_file_name[FN_REFLEN], *name;
3459 36180 const char *log_file_name = lex_mi->log_file_name;
3460 36180 Log_event *ev = nullptr;
3461
3462
1/2
✓ Branch 0 taken 18090 times.
✗ Branch 1 not taken.
 36180 unit->set_limit(thd, thd->lex->current_query_block());
3463 36180 limit_start = unit->offset_limit_cnt;
3464 36180 limit_end = unit->select_limit_cnt;
3465
3466 36180 name = search_file_name;
3467
2/2
✓ Branch 0 taken 14272 times.
✓ Branch 1 taken 3818 times.
 36180 if (log_file_name)
3468
1/2
✓ Branch 0 taken 14272 times.
✗ Branch 1 not taken.
 28544 binary_log->make_log_name(search_file_name, log_file_name);
3469 else
3470 7636 name = nullptr; // Find first log
3471
3472 36180 linfo.index_file_offset = 0;
3473
3474
3/4
✓ Branch 0 taken 18090 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 18077 times.
 36180 if (binary_log->find_log_pos(&linfo, name, true /*need_lock_index=true*/)) {
3475
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
 26 errmsg = "Could not find target log";
3476 60 goto err;
3477 }
3478
3479
1/2
✓ Branch 0 taken 18077 times.
✗ Branch 1 not taken.
 36154 mysql_mutex_lock(&thd->LOCK_thd_data);
3480 36154 thd->current_linfo = &linfo;
3481
1/2
✓ Branch 0 taken 18077 times.
✗ Branch 1 not taken.
 36154 mysql_mutex_unlock(&thd->LOCK_thd_data);
3482
3483
1/2
✓ Branch 0 taken 18077 times.
✗ Branch 1 not taken.
 36154 BINLOG_FILE_READER binlog_file_reader(
3484 opt_source_verify_checksum,
3485 36154 std::max(thd->variables.max_allowed_packet,
3486 36154 binlog_row_event_max_size + MAX_LOG_EVENT_HEADER));
3487
3488
3/4
✓ Branch 0 taken 18077 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 18060 times.
 36154 if (binlog_file_reader.open(linfo.log_file_name, pos)) {
3489
2/4
✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✗ Branch 3 not taken.
 34 errmsg = binlog_file_reader.get_error_str();
3490 34 goto err;
3491 }
3492
3493 /*
3494 Adjust the pos to the correct starting offset of an event after the
3495 specified position if it is an invalid starting offset.
3496 */
3497 36120 pos = binlog_file_reader.position();
3498
3499 /*
3500 For 'in-active' binlog file, it is safe to read all events in it. But
3501 for 'active' binlog file, it is only safe to read the events before
3502 get_binlog_end_pos().
3503
3504 Binlog rotation may happen after calling is_active(). In this case,
3505 end_pos will NOT be set to 0 while the file is actually not 'active'.
3506 It is safe, since 'end_pos' still expresses a correct position.
3507 */
3508 36120 my_off_t end_pos = binary_log->get_binlog_end_pos();
3509
3/4
✓ Branch 0 taken 18060 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 244 times.
✓ Branch 3 taken 17816 times.
 36120 if (!binary_log->is_active(linfo.log_file_name)) end_pos = 0;
3510
3511
2/4
✓ Branch 0 taken 18060 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18060 times.
✗ Branch 3 not taken.
 36120 DEBUG_SYNC(thd, "after_show_binlog_event_found_file");
3512
3513 /**
3514 Relaylog_file_reader and Binlog_file_reader are typedefs to
3515 Basic_binlog_file_reader whereas Relaylog_file_reader uses
3516 a Relaylog_ifile in the template instantiation and
3517 Binlog_file_reader uses a Binlog_ifile in the template
3518 instantiation.
3519
3520 Binlog_ifile and Relaylog_ifile differ only in the open()
3521 member function and they both derive from Basic_binlog_ifile.
3522
3523 Therefore, it is OK to cast to Binlog_file_reader here.
3524
3525 TODO: in the future investigate if some refactoring is needed
3526 here. Perhaps make the Iterator itself templated.
3527 */
3528
1/2
✓ Branch 0 taken 18060 times.
✗ Branch 1 not taken.
 36120 binlog::tools::Iterator it(
3529 reinterpret_cast<Binlog_file_reader *>(&binlog_file_reader));
3530
3531 /*
3532 Unpacked events shall copy their part of the buffer from uncompressed
3533 buffer (the cointainer, i.e., the buffer iterator goes out of scope
3534 once the events are inflated and put in a vector). However, it is
3535 unclear if the *buffer* from which events are deserialized is still
3536 needed for the porposes of displaying events in SHOW BINLOG/RELAYLOG
3537 EVENTS.
3538 */
3539 36120 my_off_t last_log_pos = 0;
3540
4/6
✓ Branch 0 taken 18060 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 207113 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 201144 times.
✓ Branch 5 taken 5969 times.
 414226 for (event_count = 0, ev = it.begin(); ev != it.end();) {
3541
2/4
✓ Branch 0 taken 201144 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 201144 times.
✗ Branch 3 not taken.
 402288 DEBUG_SYNC(thd, "wait_in_show_binlog_events_loop");
3542
3/4
✓ Branch 0 taken 200877 times.
✓ Branch 1 taken 267 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 201144 times.
 804042 if (event_count >= limit_start &&
3543
2/4
✓ Branch 0 taken 200877 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 200877 times.
 401754 ev->net_send(protocol, linfo.log_file_name, pos)) {
3544 /* purecov: begin inspected */
3545 ✗ errmsg = "Net error";
3546 ✗ delete ev;
3547 ✗ ev = nullptr;
3548 ✗ goto err;
3549 /* purecov: end */
3550 }
3551 402288 last_log_pos = ev->common_header->log_pos;
3552
1/2
✓ Branch 0 taken 201144 times.
✗ Branch 1 not taken.
 402288 delete ev;
3553 402288 ev = nullptr;
3554 402288 pos = binlog_file_reader.position();
3555
3556
2/2
✓ Branch 0 taken 1543 times.
✓ Branch 1 taken 199601 times.
 402288 if (++event_count == limit_end) break;
3557
4/6
✓ Branch 0 taken 199601 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 199601 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10547 times.
✓ Branch 5 taken 189054 times.
 399202 if ((ev = it.next()) == it.end()) break;
3558
2/4
✓ Branch 0 taken 189054 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 189054 times.
 378108 if (it.has_error()) break;
3559
4/4
✓ Branch 0 taken 187359 times.
✓ Branch 1 taken 1695 times.
✓ Branch 2 taken 187 times.
✓ Branch 3 taken 187172 times.
 378108 if (end_pos > 0 && pos >= end_pos &&
3560
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 186 times.
 374 (ev->common_header->log_pos != last_log_pos)) {
3561
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 2 delete ev;
3562 2 ev = nullptr;
3563 2 break;
3564 }
3565 }
3566
3567
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 18059 times.
 36120 if (binlog_file_reader.has_fatal_error())
3568
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 2 errmsg = binlog_file_reader.get_error_str();
3569
2/4
✓ Branch 0 taken 18059 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 18059 times.
 36118 else if (it.has_error())
3570 ✗ errmsg = it.get_error_message(); /* purecov: inspected */
3571 else
3572
1/2
✓ Branch 0 taken 18059 times.
✗ Branch 1 not taken.
 36118 errmsg = "";
3573
3/4
✓ Branch 0 taken 18060 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18060 times.
✓ Branch 3 taken 17 times.
 36154 }
3574 // Check that linfo is still on the function scope.
3575
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 18066 times.
✓ Branch 2 taken 18066 times.
✗ Branch 3 not taken.
 36132 DEBUG_SYNC(thd, "after_show_binlog_events");
3576
3577 ✗ err:
3578
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 18065 times.
 36192 if (!errmsg.empty()) {
3579
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 29 times.
 62 if (thd->lex->sql_command == SQLCOM_SHOW_RELAYLOG_EVENTS)
3580
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 4 my_error(ER_ERROR_WHEN_EXECUTING_COMMAND, MYF(0), "SHOW RELAYLOG EVENTS",
3581 errmsg.c_str());
3582 else
3583
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 58 my_error(ER_ERROR_WHEN_EXECUTING_COMMAND, MYF(0), "SHOW BINLOG EVENTS",
3584 errmsg.c_str());
3585 } else
3586
1/2
✓ Branch 0 taken 18065 times.
✗ Branch 1 not taken.
 36130 my_eof(thd);
3587
3588
1/2
✓ Branch 0 taken 18096 times.
✗ Branch 1 not taken.
 36192 mysql_mutex_lock(&thd->LOCK_thd_data);
3589 36192 thd->current_linfo = nullptr;
3590
1/2
✓ Branch 0 taken 18096 times.
✗ Branch 1 not taken.
 36192 mysql_mutex_unlock(&thd->LOCK_thd_data);
3591 72384 return !errmsg.empty();
3592 36192 }
3593
3594 18096 bool show_binlog_events(THD *thd, MYSQL_BIN_LOG *binary_log) {
3595
2/2
✓ Branch 0 taken 1253 times.
✓ Branch 1 taken 16843 times.
 18096 if (binary_log->is_relay_log)
3596 1253 return show_binlog_events<Relaylog_file_reader>(thd, binary_log);
3597 16843 return show_binlog_events<Binlog_file_reader>(thd, binary_log);
3598 }
3599
3600 /**
3601 Execute a SHOW BINLOG EVENTS statement.
3602
3603 @param thd Pointer to THD object for the client thread executing the
3604 statement.
3605
3606 @retval false success
3607 @retval true failure
3608 */
3609 16843 bool mysql_show_binlog_events(THD *thd) {
3610
1/2
✓ Branch 0 taken 16843 times.
✗ Branch 1 not taken.
 16843 DBUG_TRACE;
3611
3612
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16843 times.
 16843 assert(thd->lex->sql_command == SQLCOM_SHOW_BINLOG_EVENTS);
3613
3614 16843 mem_root_deque<Item *> field_list(thd->mem_root);
3615
1/2
✓ Branch 0 taken 16843 times.
✗ Branch 1 not taken.
 16843 Log_event::init_show_field_list(&field_list);
3616
2/4
✓ Branch 0 taken 16843 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16843 times.
 16843 if (thd->send_result_metadata(field_list,
3617 Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
3618 ✗ return true;
3619
3620 /*
3621 Wait for handlers to insert any pending information
3622 into the binlog. For e.g. ndb which updates the binlog asynchronously
3623 this is needed so that the uses sees all its own commands in the binlog
3624 */
3625
1/2
✓ Branch 0 taken 16843 times.
✗ Branch 1 not taken.
 16843 ha_binlog_wait(thd);
3626
3627
1/2
✓ Branch 0 taken 16843 times.
✗ Branch 1 not taken.
 16843 return show_binlog_events(thd, &mysql_bin_log);
3628 16843 }
3629
3630 137328 MYSQL_BIN_LOG::MYSQL_BIN_LOG(uint *sync_period, bool relay_log)
3631 137328 : name(nullptr),
3632 137328 write_error(false),
3633 137328 inited(false),
3634
1/2
✓ Branch 0 taken 137328 times.
✗ Branch 1 not taken.
 137328 m_binlog_file(new Binlog_ofile()),
3635 137328 m_key_LOCK_log(key_LOG_LOCK_log),
3636 137328 bytes_written(0),
3637 137328 binlog_space_total(0),
3638 137328 file_id(1),
3639 137328 sync_period_ptr(sync_period),
3640 137328 sync_counter(0),
3641 137328 is_relay_log(relay_log),
3642 137328 checksum_alg_reset(binary_log::BINLOG_CHECKSUM_ALG_UNDEF),
3643 137328 relay_log_checksum_alg(binary_log::BINLOG_CHECKSUM_ALG_UNDEF),
3644 137328 previous_gtid_set_relaylog(nullptr),
3645 137328 snapshot_lock_acquired(false),
3646
1/2
✓ Branch 0 taken 137328 times.
✗ Branch 1 not taken.
 274656 is_rotating_caused_by_incident(false) {
3647 /*
3648 We don't want to initialize locks here as such initialization depends on
3649 safe_mutex (when using safe_mutex) which depends on MY_INIT(), which is
3650 called only in main(). Doing initialization here would make it happen
3651 before main().
3652 */
3653 137328 index_file_name[0] = 0;
3654 137328 }
3655
3656
2/2
✓ Branch 0 taken 101519 times.
✓ Branch 1 taken 31099 times.
 265236 MYSQL_BIN_LOG::~MYSQL_BIN_LOG() { delete m_binlog_file; }
3657
3658 /* this is called only once */
3659
3660 31101 void MYSQL_BIN_LOG::cleanup() {
3661
1/2
✓ Branch 0 taken 31101 times.
✗ Branch 1 not taken.
 31101 DBUG_TRACE;
3662
2/2
✓ Branch 0 taken 31099 times.
✓ Branch 1 taken 2 times.
 31101 if (inited) {
3663 31099 inited = false;
3664
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT, true /*need_lock_log=true*/,
3665 true /*need_lock_index=true*/);
3666
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 mysql_mutex_destroy(&LOCK_log);
3667
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 mysql_mutex_destroy(&LOCK_index);
3668
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 mysql_mutex_destroy(&LOCK_commit);
3669
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 mysql_mutex_destroy(&LOCK_sync);
3670
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 mysql_mutex_destroy(&LOCK_binlog_end_pos);
3671
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 mysql_mutex_destroy(&LOCK_xids);
3672
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 mysql_cond_destroy(&update_cond);
3673
1/2
✓ Branch 0 taken 31099 times.
✗ Branch 1 not taken.
 31099 mysql_cond_destroy(&m_prep_xids_cond);
3674
2/2
✓ Branch 0 taken 10524 times.
✓ Branch 1 taken 20575 times.
 31099 if (!is_relay_log) {
3675
2/4
✓ Branch 0 taken 10524 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10524 times.
✗ Branch 3 not taken.
 10524 Commit_stage_manager::get_instance().deinit();
3676 }
3677 }
3678
3679
2/2
✓ Branch 0 taken 31099 times.
✓ Branch 1 taken 2 times.
 31101 delete m_binlog_file;
3680 31101 m_binlog_file = nullptr;
3681 31101 }
3682
3683 34316 void MYSQL_BIN_LOG::init_pthread_objects() {
3684
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34316 times.
 34316 assert(inited == 0);
3685 34316 inited = true;
3686
3687 34316 mysql_mutex_init(m_key_LOCK_log, &LOCK_log, MY_MUTEX_INIT_SLOW);
3688 34316 mysql_mutex_init(m_key_LOCK_index, &LOCK_index, MY_MUTEX_INIT_SLOW);
3689 34316 mysql_mutex_init(m_key_LOCK_commit, &LOCK_commit, MY_MUTEX_INIT_FAST);
3690 34316 mysql_mutex_init(m_key_LOCK_sync, &LOCK_sync, MY_MUTEX_INIT_FAST);
3691 34316 mysql_mutex_init(m_key_LOCK_binlog_end_pos, &LOCK_binlog_end_pos,
3692 MY_MUTEX_INIT_FAST);
3693 34316 mysql_mutex_init(m_key_LOCK_xids, &LOCK_xids, MY_MUTEX_INIT_FAST);
3694 34316 mysql_cond_init(m_key_update_cond, &update_cond);
3695 34316 mysql_cond_init(m_key_prep_xids_cond, &m_prep_xids_cond);
3696
2/2
✓ Branch 0 taken 12142 times.
✓ Branch 1 taken 22174 times.
 34316 if (!is_relay_log) {
3697 12142 Commit_stage_manager::get_instance().init(
3698 m_key_LOCK_flush_queue, m_key_LOCK_sync_queue, m_key_LOCK_commit_queue,
3699 m_key_LOCK_done, m_key_COND_done, m_key_COND_flush_queue);
3700 }
3701 34316 }
3702
3703 /**
3704 Check if a string is a valid number.
3705
3706 @param str String to test
3707 @param res Store value here
3708 @param allow_wildcards Set to 1 if we should ignore '%' and '_'
3709
3710 @note
3711 For the moment the allow_wildcards argument is not used
3712 Should be moved to some other file.
3713
3714 @retval
3715 1 String is a number
3716 @retval
3717 0 String is not a number
3718 */
3719
3720 4892428 static bool is_number(const char *str, ulong *res, bool allow_wildcards) {
3721 int flag;
3722 const char *start;
3723
1/2
✓ Branch 0 taken 4892428 times.
✗ Branch 1 not taken.
 4892428 DBUG_TRACE;
3724
3725 4892428 flag = 0;
3726 4892428 start = str;
3727
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4892428 times.
 4892428 while (*str++ == ' ')
3728 ;
3729
3/6
✓ Branch 0 taken 4892428 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4892428 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 4892428 times.
 4892428 if (*--str == '-' || *str == '+') str++;
3730
3/4
✓ Branch 0 taken 28241944 times.
✓ Branch 1 taken 4892428 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4892428 times.
 33134372 while (my_isdigit(files_charset_info, *str) ||
3731 ✗ (allow_wildcards && (*str == wild_many || *str == wild_one))) {
3732 28241944 flag = 1;
3733 28241944 str++;
3734 }
3735
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 4892418 times.
 4892428 if (*str == '.') {
3736
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
 10 for (str++; my_isdigit(files_charset_info, *str) ||
3737 ✗ (allow_wildcards && (*str == wild_many || *str == wild_one));
3738 ✗ str++, flag = 1)
3739 ;
3740 }
3741
3/4
✓ Branch 0 taken 4706968 times.
✓ Branch 1 taken 185460 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4706968 times.
 4892428 if (*str != 0 || flag == 0) return false;
3742
1/2
✓ Branch 0 taken 4706968 times.
✗ Branch 1 not taken.
 4706968 if (res) *res = atol(start);
3743 4706968 return true; /* Number ok */
3744 4892428 } /* is_number */
3745
3746 /**
3747 Find a unique filename for 'filename.#'.
3748
3749 Set '#' to the highest existing log file extension plus one.
3750
3751 This function will return nonzero if: (i) the generated name
3752 exceeds FN_REFLEN; (ii) if the number of extensions is exhausted;
3753 or (iii) some other error happened while examining the filesystem.
3754
3755 @return
3756 nonzero if not possible to get unique filename.
3757 */
3758
3759 134957 static int find_uniq_filename(char *name, uint32 new_index_number) {
3760 uint i;
3761 char buff[FN_REFLEN], ext_buf[FN_REFLEN];
3762 134957 MY_DIR *dir_info = nullptr;
3763 struct fileinfo *file_info;
3764 134957 ulong max_found = 0, next = 0, number = 0;
3765 size_t buf_length, length;
3766 char *start, *end;
3767 134957 int error = 0;
3768
1/2
✓ Branch 0 taken 134957 times.
✗ Branch 1 not taken.
 134957 DBUG_TRACE;
3769
3770
1/2
✓ Branch 0 taken 134957 times.
✗ Branch 1 not taken.
 134957 length = dirname_part(buff, name, &buf_length);
3771 134957 start = name + length;
3772 134957 end = strend(start);
3773
3774 134957 *end = '.';
3775 134957 length = (size_t)(end - start + 1);
3776
3777
7/10
✓ Branch 0 taken 134957 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 134944 times.
✓ Branch 3 taken 13 times.
✓ Branch 4 taken 134944 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 134944 times.
✓ Branch 8 taken 13 times.
✓ Branch 9 taken 134944 times.
 134957 if ((DBUG_EVALUATE_IF(
3778 "error_unique_log_filename", 1,
3779 !(dir_info =
3780 my_dir(buff, MYF(MY_DONT_SORT)))))) { // This shouldn't happen
3781 13 my_stpcpy(end, ".1"); // use name+1
3782 13 return 1;
3783 }
3784 134944 file_info = dir_info->dir_entry;
3785
2/2
✓ Branch 0 taken 7878206 times.
✓ Branch 1 taken 134944 times.
 8013150 for (i = dir_info->number_off_files; i--; file_info++) {
3786
4/4
✓ Branch 0 taken 4892428 times.
✓ Branch 1 taken 2985778 times.
✓ Branch 2 taken 4706968 times.
✓ Branch 3 taken 3171238 times.
 12770634 if (strncmp(file_info->name, start, length) == 0 &&
3787
3/4
✓ Branch 0 taken 4892428 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4706968 times.
✓ Branch 3 taken 185460 times.
 4892428 is_number(file_info->name + length, &number, false)) {
3788 4706968 max_found = std::max(max_found, number);
3789 }
3790 }
3791
1/2
✓ Branch 0 taken 134944 times.
✗ Branch 1 not taken.
 134944 my_dirend(dir_info);
3792
3793 /* check if reached the maximum possible extension number */
3794
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 134939 times.
 134944 if (max_found >= MAX_LOG_UNIQUE_FN_EXT) {
3795
8/16
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 5 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 5 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 5 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 5 times.
✗ Branch 15 not taken.
 5 LogErr(ERROR_LEVEL, ER_BINLOG_FILE_EXTENSION_NUMBER_EXHAUSTED, max_found);
3796 5 error = 1;
3797 5 goto end;
3798 }
3799
3800
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 134927 times.
 134939 if (new_index_number > 0) {
3801 /*
3802 If "new_index_number" was specified, this means we are handling a
3803 "RESET MASTER TO" command and the binary log was already purged
3804 so max_found should be 0.
3805 */
3806
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 assert(max_found == 0);
3807 12 next = new_index_number;
3808 } else
3809 134927 next = max_found + 1;
3810
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134939 times.
 134939 if (sprintf(ext_buf, "%06lu", next) < 0) {
3811 ✗ error = 1;
3812 ✗ goto end;
3813 }
3814 134939 *end++ = '.';
3815
3816 /*
3817 Check if the generated extension size + the file name exceeds the
3818 buffer size used. If one did not check this, then the filename might be
3819 truncated, resulting in error.
3820 */
3821
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134939 times.
 134939 if (((strlen(ext_buf) + (end - name)) >= FN_REFLEN)) {
3822 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FILE_NAME_TOO_LONG, name, ext_buf,
3823 (strlen(ext_buf) + (end - name)));
3824 ✗ error = 1;
3825 ✗ goto end;
3826 }
3827
3828
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134939 times.
 134939 if (sprintf(end, "%06lu", next) < 0) {
3829 ✗ error = 1;
3830 ✗ goto end;
3831 }
3832
3833 /* print warning if reaching the end of available extensions. */
3834
2/2
✓ Branch 0 taken 134931 times.
✓ Branch 1 taken 8 times.
 134939 if (next > MAX_ALLOWED_FN_EXT_RESET_MASTER)
3835
8/16
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 8 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 8 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 8 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 8 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 8 times.
✗ Branch 15 not taken.
 8 LogErr(WARNING_LEVEL, ER_BINLOG_FILE_EXTENSION_NUMBER_RUNNING_LOW, next,
3836 (MAX_LOG_UNIQUE_FN_EXT - next));
3837
3838 134931 end:
3839 134944 return error;
3840 134957 }
3841
3842 134957 int MYSQL_BIN_LOG::generate_new_name(char *new_name, const char *log_name,
3843 uint32 new_index_number) {
3844 134957 fn_format(new_name, log_name, mysql_data_home, "", 4);
3845
1/2
✓ Branch 0 taken 134957 times.
✗ Branch 1 not taken.
 134957 if (!fn_ext(log_name)[0]) {
3846
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 134939 times.
 134957 if (find_uniq_filename(new_name, new_index_number)) {
3847
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.
 18 if (current_thd != nullptr)
3848 16 my_printf_error(ER_NO_UNIQUE_LOGFILE,
3849 16 ER_THD(current_thd, ER_NO_UNIQUE_LOGFILE),
3850 MYF(ME_FATALERROR), log_name);
3851
7/14
✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 18 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 18 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 18 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 18 times.
✗ Branch 13 not taken.
 18 LogErr(ERROR_LEVEL, ER_FAILED_TO_GENERATE_UNIQUE_LOGFILE, log_name);
3852 18 return 1;
3853 }
3854 }
3855 134939 return 0;
3856 }
3857
3858 /**
3859 @todo
3860 The following should be using fn_format(); We just need to
3861 first change fn_format() to cut the file name if it's too long.
3862 */
3863 23605 const char *MYSQL_BIN_LOG::generate_name(const char *log_name,
3864 const char *suffix, char *buff) {
3865
3/4
✓ Branch 0 taken 16305 times.
✓ Branch 1 taken 7300 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16305 times.
 23605 if (!log_name || !log_name[0]) {
3866
3/4
✓ Branch 0 taken 7300 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 49 times.
✓ Branch 3 taken 7251 times.
 7300 if (is_relay_log || log_bin_supplied)
3867 49 strmake(buff, default_logfile_name, FN_REFLEN - strlen(suffix) - 1);
3868 else
3869 7251 strmake(buff, default_binlogfile_name, FN_REFLEN - strlen(suffix) - 1);
3870
3871 7300 return (const char *)fn_format(buff, buff, "", suffix,
3872 7300 MYF(MY_REPLACE_EXT | MY_REPLACE_DIR));
3873 }
3874 // get rid of extension to avoid problems
3875
3876 16305 const char *p = fn_ext(log_name);
3877 16305 uint length = (uint)(p - log_name);
3878
1/2
✓ Branch 0 taken 16305 times.
✗ Branch 1 not taken.
 16305 strmake(buff, log_name, min<size_t>(length, FN_REFLEN - 1));
3879 16305 return (const char *)buff;
3880 }
3881
3882 168877 bool MYSQL_BIN_LOG::init_and_set_log_file_name(const char *log_name,
3883 const char *new_name,
3884 uint32 new_index_number) {
3885
4/6
✓ Branch 0 taken 67894 times.
✓ Branch 1 taken 100983 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 67894 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 168877 times.
 168877 if (new_name && !my_stpcpy(log_file_name, new_name))
3886 ✗ return true;
3887
4/4
✓ Branch 0 taken 100983 times.
✓ Branch 1 taken 67894 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 168874 times.
 269860 else if (!new_name &&
3888
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 100980 times.
 100983 generate_new_name(log_file_name, log_name, new_index_number))
3889 3 return true;
3890
3891 168874 return false;
3892 }
3893
3894 /**
3895 Open the logfile and init IO_CACHE.
3896
3897 @param log_file_key The file instrumentation key for this file
3898 @param log_name The name of the log to open
3899 @param new_name The new name for the logfile.
3900 NULL forces generate_new_name() to be called.
3901 @param new_index_number The binary log file index number to start from
3902 after the RESET MASTER TO command is called.
3903
3904 @return true if error, false otherwise.
3905 */
3906
3907 84432 bool MYSQL_BIN_LOG::open(PSI_file_key log_file_key, const char *log_name,
3908 const char *new_name, uint32 new_index_number) {
3909
1/2
✓ Branch 0 taken 84432 times.
✗ Branch 1 not taken.
 84432 DBUG_TRACE;
3910 84432 bool ret = false;
3911
3912 84432 write_error = false;
3913 84432 myf flags = MY_WME | MY_NABP | MY_WAIT_IF_FULL;
3914
2/2
✓ Branch 0 taken 53769 times.
✓ Branch 1 taken 30663 times.
 84432 if (is_relay_log) flags = flags | MY_REPORT_WAITING_IF_FULL;
3915
3916
2/4
✓ Branch 0 taken 84432 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84432 times.
 84432 if (!(name = my_strdup(key_memory_MYSQL_LOG_name, log_name, MYF(MY_WME)))) {
3917 ✗ goto err;
3918 }
3919
3920
4/6
✓ Branch 0 taken 84432 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84432 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 84431 times.
 168864 if (init_and_set_log_file_name(name, new_name, new_index_number) ||
3921
3/4
✓ Branch 0 taken 84432 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 84431 times.
 84432 DBUG_EVALUATE_IF("fault_injection_init_name", 1, 0))
3922 1 goto err;
3923
3924 84431 db[0] = 0;
3925
3926 /* Keep the key for reopen */
3927 84431 m_log_file_key = log_file_key;
3928
3929 /*
3930 LOCK_sync guarantees that no thread is calling m_binlog_file to sync data
3931 to disk when another thread is opening the new file
3932 (FLUSH LOG or RESET MASTER).
3933 */
3934
3/4
✓ Branch 0 taken 30662 times.
✓ Branch 1 taken 53769 times.
✓ Branch 2 taken 30662 times.
✗ Branch 3 not taken.
 84431 if (!is_relay_log) mysql_mutex_lock(&LOCK_sync);
3935
3936
1/2
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
 84431 ret = m_binlog_file->open(log_file_key, log_file_name, flags);
3937
3938
3/4
✓ Branch 0 taken 30662 times.
✓ Branch 1 taken 53769 times.
✓ Branch 2 taken 30662 times.
✗ Branch 3 not taken.
 84431 if (!is_relay_log) mysql_mutex_unlock(&LOCK_sync);
3939
3940
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84431 times.
 84431 if (ret) goto err;
3941
3942 84431 atomic_log_state = LOG_OPENED;
3943 84431 return false;
3944
3945 1 err:
3946
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (binlog_error_action == ABORT_SERVER) {
3947 ✗ exec_binlog_error_action_abort(
3948 "Either disk is full, file system is read only or "
3949 "there was an encryption error while opening the binlog. "
3950 "Aborting the server.");
3951 } else
3952
8/16
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
 1 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_FOR_LOGGING, log_name, errno);
3953
3954
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 my_free(name);
3955 1 name = nullptr;
3956 1 atomic_log_state = LOG_CLOSED;
3957 1 return true;
3958 84432 }
3959
3960 84651 bool MYSQL_BIN_LOG::open_index_file(const char *index_file_name_arg,
3961 const char *log_name,
3962 bool need_lock_index) {
3963 84651 bool error = false;
3964 84651 File index_file_nr = -1;
3965
2/2
✓ Branch 0 taken 23571 times.
✓ Branch 1 taken 61080 times.
 84651 if (need_lock_index)
3966 23571 mysql_mutex_lock(&LOCK_index);
3967 else
3968 61080 mysql_mutex_assert_owner(&LOCK_index);
3969
3970 /*
3971 First open of this class instance
3972 Create an index file that will hold all file names uses for logging.
3973 Add new entries to the end of it.
3974 */
3975 84651 myf opt = MY_UNPACK_FILENAME;
3976
3977
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 84650 times.
 84651 if (my_b_inited(&index_file)) goto end;
3978
3979
2/2
✓ Branch 0 taken 23549 times.
✓ Branch 1 taken 61101 times.
 84650 if (!index_file_name_arg) {
3980 23549 index_file_name_arg = log_name; // Use same basename for index file
3981 23549 opt = MY_UNPACK_FILENAME | MY_REPLACE_EXT;
3982 }
3983 84650 fn_format(index_file_name, index_file_name_arg, mysql_data_home, ".index",
3984 opt);
3985
3986
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84650 times.
 84650 if (set_crash_safe_index_file_name(index_file_name_arg)) {
3987 ✗ error = true;
3988 ✗ goto end;
3989 }
3990
3991 /*
3992 We need move crash_safe_index_file to index_file if the index_file
3993 does not exist and crash_safe_index_file exists when mysqld server
3994 restarts.
3995 */
3996
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 37529 times.
 122185 if (my_access(index_file_name, F_OK) &&
3997
3/4
✓ Branch 0 taken 37535 times.
✓ Branch 1 taken 47115 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 84650 times.
 122185 !my_access(crash_safe_index_file_name, F_OK) &&
3998
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 my_rename(crash_safe_index_file_name, index_file_name, MYF(MY_WME))) {
3999 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_MOVE_TMP_TO_INDEX,
4000 "MYSQL_BIN_LOG::open_index_file");
4001 ✗ error = true;
4002 ✗ goto end;
4003 }
4004
4005 84650 if ((index_file_nr = mysql_file_open(m_key_file_log_index, index_file_name,
4006 84649 O_RDWR | O_CREAT, MYF(MY_WME))) < 0 ||
4007
1/2
✓ Branch 0 taken 84649 times.
✗ Branch 1 not taken.
 84649 mysql_file_sync(index_file_nr, MYF(MY_WME)) ||
4008
1/2
✓ Branch 0 taken 84649 times.
✗ Branch 1 not taken.
 84649 init_io_cache_ext(&index_file, index_file_nr, IO_SIZE, READ_CACHE,
4009 mysql_file_seek(index_file_nr, 0L, MY_SEEK_END, MYF(0)),
4010 false, MYF(MY_WME | MY_WAIT_IF_FULL),
4011
4/4
✓ Branch 0 taken 84649 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 84647 times.
 169299 m_key_file_log_index_cache) ||
4012
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 84647 times.
 84649 DBUG_EVALUATE_IF("fault_injection_openning_index", 1, 0)) {
4013 /*
4014 TODO: all operations creating/deleting the index file or a log, should
4015 call my_sync_dir() or my_sync_dir_by_file() to be durable.
4016 TODO: file creation should be done with mysql_file_create()
4017 not mysql_file_open().
4018 */
4019
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 if (index_file_nr >= 0) mysql_file_close(index_file_nr, MYF(0));
4020 3 error = true;
4021 3 goto end;
4022 }
4023
4024 /*
4025 Sync the index by purging any binary log file that is not registered.
4026 In other words, either purge binary log files that were removed from
4027 the index but not purged from the file system due to a crash or purge
4028 any binary log file that was created but not register in the index
4029 due to a crash.
4030 */
4031
4032 84647 if (set_purge_index_file_name(index_file_name_arg) ||
4033
1/2
✓ Branch 0 taken 84647 times.
✗ Branch 1 not taken.
 84647 open_purge_index_file(false) ||
4034
4/8
✓ Branch 0 taken 84647 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84647 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 84647 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 84647 times.
✗ Branch 7 not taken.
 253941 purge_index_entry(nullptr, nullptr, false) || close_purge_index_file() ||
4035
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84647 times.
 84647 DBUG_EVALUATE_IF("fault_injection_recovering_index", 1, 0)) {
4036 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_SYNC_INDEX_FILE);
4037 ✗ error = true;
4038 ✗ goto end;
4039 }
4040
4041 84647 end:
4042
2/2
✓ Branch 0 taken 23571 times.
✓ Branch 1 taken 61080 times.
 84651 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
4043 84651 return error;
4044 }
4045
4046 /**
4047 Add the GTIDs from the given relaylog file and also
4048 update the IO thread transaction parser.
4049
4050 @param filename Relaylog file to read from.
4051 @param retrieved_gtids Gtid_set to store the GTIDs found on the relaylog file.
4052 @param verify_checksum Set to true to verify event checksums.
4053 @param trx_parser The transaction boundary parser to be used in order to
4054 only add a GTID to the gtid_set after ensuring the transaction is fully
4055 stored on the relay log.
4056 @param partial_trx The trx_monitoring_info of the last incomplete transaction
4057 found in the relay log.
4058
4059 @retval false The file was successfully read and all GTIDs from
4060 Previous_gtids and Gtid_log_event from complete transactions were added to
4061 the retrieved_set.
4062 @retval true There was an error during the procedure.
4063 */
4064 9732 static bool read_gtids_and_update_trx_parser_from_relaylog(
4065 const char *filename, Gtid_set *retrieved_gtids, bool verify_checksum,
4066 Transaction_boundary_parser *trx_parser,
4067 Gtid_monitoring_info *partial_trx) {
4068
1/2
✓ Branch 0 taken 9732 times.
✗ Branch 1 not taken.
 9732 DBUG_TRACE;
4069
3/8
✓ Branch 0 taken 9732 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9732 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9732 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 9732 DBUG_PRINT("info", ("Opening file %s", filename));
4070
4071
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9732 times.
 9732 assert(retrieved_gtids != nullptr);
4072
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9732 times.
 9732 assert(trx_parser != nullptr);
4073 #ifndef NDEBUG
4074 9732 unsigned long event_counter = 0;
4075 #endif
4076 9732 bool error = false;
4077
4078
1/2
✓ Branch 0 taken 9732 times.
✗ Branch 1 not taken.
 9732 Relaylog_file_reader relaylog_file_reader(verify_checksum);
4079
3/4
✓ Branch 0 taken 9732 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 9726 times.
 9732 if (relaylog_file_reader.open(filename)) {
4080
9/18
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 6 times.
✗ Branch 17 not taken.
 6 LogErr(ERROR_LEVEL, ER_BINLOG_FILE_OPEN_FAILED,
4081 relaylog_file_reader.get_error_str());
4082
4083 /*
4084 As read_gtids_from_binlog() will not throw error on truncated
4085 relaylog files, we should do the same here in order to keep the
4086 current behavior.
4087 */
4088
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (relaylog_file_reader.get_error_type() ==
4089 Binlog_read_error::CANNOT_GET_FILE_PASSWORD)
4090 ✗ error = true;
4091 6 return error;
4092 }
4093
4094 9726 Log_event *ev = nullptr;
4095 9726 bool seen_prev_gtids = false;
4096 9726 ulong data_len = 0;
4097
4098
6/8
✓ Branch 0 taken 48819 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 48819 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 39093 times.
✓ Branch 5 taken 9726 times.
✓ Branch 6 taken 39093 times.
✓ Branch 7 taken 9726 times.
 48819 while (!error && (ev = relaylog_file_reader.read_event_object()) != nullptr) {
4099
3/10
✓ Branch 0 taken 39093 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39093 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 39093 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 39093 DBUG_PRINT("info", ("Read event of type %s", ev->get_type_str()));
4100 #ifndef NDEBUG
4101 39093 event_counter++;
4102 #endif
4103
4104 39093 data_len = uint4korr(ev->temp_buf + EVENT_LEN_OFFSET);
4105
4106 39093 bool info_error{false};
4107 39093 binary_log::Log_event_basic_info log_event_info;
4108 78186 std::tie(info_error, log_event_info) = extract_log_event_basic_info(
4109
1/2
✓ Branch 0 taken 39093 times.
✗ Branch 1 not taken.
 39093 ev->temp_buf, data_len,
4110 39093 relaylog_file_reader.format_description_event());
4111
4112
6/8
✓ Branch 0 taken 39093 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39093 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 39090 times.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 39090 times.
 39093 if (info_error || trx_parser->feed_event(log_event_info, false)) {
4113 /*
4114 The transaction boundary parser found an error while parsing a
4115 sequence of events from the relaylog. As we don't know if the
4116 parsing has started from a reliable point (it might started in
4117 a relay log file that begins with the rest of a transaction
4118 that started in a previous relay log file), it is better to do
4119 nothing in this case. The boundary parser will fix itself once
4120 finding an event that represent a transaction boundary.
4121
4122 Suppose the following relaylog:
4123
4124 rl-bin.000011 | rl-bin.000012 | rl-bin.000013 | rl-bin-000014
4125 ---------------+---------------+---------------+---------------
4126 PREV_GTIDS | PREV_GTIDS | PREV_GTIDS | PREV_GTIDS
4127 (empty) | (UUID:1-2) | (UUID:1-2) | (UUID:1-2)
4128 ---------------+---------------+---------------+---------------
4129 XID | QUERY(INSERT) | QUERY(INSERT) | XID
4130 ---------------+---------------+---------------+---------------
4131 GTID(UUID:2) |
4132 ---------------+
4133 QUERY(CREATE |
4134 TABLE t1 ...) |
4135 ---------------+
4136 GTID(UUID:3) |
4137 ---------------+
4138 QUERY(BEGIN) |
4139 ---------------+
4140
4141 As it is impossible to determine the current Retrieved_Gtid_Set by only
4142 looking to the PREVIOUS_GTIDS on the last relay log file, and scanning
4143 events on it, we tried to find a relay log file that contains at least
4144 one GTID event during the backwards search.
4145
4146 In the example, we will find a GTID only in rl-bin.000011, as the
4147 UUID:3 transaction was spanned across 4 relay log files.
4148
4149 The transaction spanning can be caused by "FLUSH RELAY LOGS" commands
4150 on slave while it is queuing the transaction.
4151
4152 So, in order to correctly add UUID:3 into Retrieved_Gtid_Set, we need
4153 to parse the relay log starting on the file we found the last GTID
4154 queued to know if the transaction was fully retrieved or not.
4155
4156 Start scanning rl-bin.000011 after resetting the transaction parser
4157 will generate an error, as XID event is only expected inside a DML,
4158 but in this case, we can ignore this error and reset the parser.
4159 */
4160
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 trx_parser->reset();
4161 /*
4162 We also have to discard the GTID of the partial transaction that was
4163 not finished if there is one. This is needed supposing that an
4164 incomplete transaction was replicated with a GTID.
4165
4166 GTID(1), QUERY(BEGIN), QUERY(INSERT), ANONYMOUS_GTID, QUERY(DROP ...)
4167
4168 In the example above, without cleaning the partial_trx,
4169 the GTID(1) would be added to the Retrieved_Gtid_Set after the
4170 QUERY(DROP ...) event.
4171
4172 GTID(1), QUERY(BEGIN), QUERY(INSERT), GTID(2), QUERY(DROP ...)
4173
4174 In the example above the GTID(1) will also be discarded as the
4175 GTID(1) transaction is not complete.
4176 */
4177
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 3 if (partial_trx->is_processing_trx_set()) {
4178 ✗ DBUG_PRINT("info",
4179 ("Discarding Gtid(%d, %" PRId64 ") as the transaction "
4180 "wasn't complete and we found an error in the"
4181 "transaction boundary parser.",
4182 partial_trx->get_processing_trx_gtid()->sidno,
4183 partial_trx->get_processing_trx_gtid()->gno));
4184 ✗ partial_trx->clear_processing_trx();
4185 }
4186 }
4187
4188
4/4
✓ Branch 0 taken 11939 times.
✓ Branch 1 taken 9726 times.
✓ Branch 2 taken 2892 times.
✓ Branch 3 taken 14536 times.
 39093 switch (ev->get_type_code()) {
4189 11939 case binary_log::FORMAT_DESCRIPTION_EVENT:
4190 case binary_log::ROTATE_EVENT:
4191 // do nothing; just accept this event and go to next
4192 11939 break;
4193 9726 case binary_log::PREVIOUS_GTIDS_LOG_EVENT: {
4194 9726 seen_prev_gtids = true;
4195 // add events to sets
4196 9726 Previous_gtids_log_event *prev_gtids_ev =
4197
1/2
✓ Branch 0 taken 9726 times.
✗ Branch 1 not taken.
 9726 (Previous_gtids_log_event *)ev;
4198
2/4
✓ Branch 0 taken 9726 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9726 times.
 9726 if (prev_gtids_ev->add_to_set(retrieved_gtids) != 0) {
4199 ✗ error = true;
4200 ✗ break;
4201 }
4202 #ifndef NDEBUG
4203
1/2
✓ Branch 0 taken 9726 times.
✗ Branch 1 not taken.
 9726 char *prev_buffer = prev_gtids_ev->get_str(nullptr, nullptr);
4204
3/8
✓ Branch 0 taken 9726 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9726 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9726 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 9726 DBUG_PRINT("info", ("Got Previous_gtids from file '%s': Gtid_set='%s'.",
4205 filename, prev_buffer));
4206
1/2
✓ Branch 0 taken 9726 times.
✗ Branch 1 not taken.
 9726 my_free(prev_buffer);
4207 #endif
4208 9726 break;
4209 }
4210 2892 case binary_log::GTID_LOG_EVENT: {
4211 /* If we didn't find any PREVIOUS_GTIDS in this file */
4212
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2892 times.
 2892 if (!seen_prev_gtids) {
4213 ✗ my_error(ER_BINLOG_LOGICAL_CORRUPTION, MYF(0), filename,
4214 "The first global transaction identifier was read, but "
4215 "no other information regarding identifiers existing "
4216 "on the previous log files was found.");
4217 ✗ error = true;
4218 ✗ break;
4219 }
4220
4221
1/2
✓ Branch 0 taken 2892 times.
✗ Branch 1 not taken.
 2892 Gtid_log_event *gtid_ev = (Gtid_log_event *)ev;
4222
1/2
✓ Branch 0 taken 2892 times.
✗ Branch 1 not taken.
 2892 rpl_sidno sidno = gtid_ev->get_sidno(retrieved_gtids->get_sid_map());
4223 2892 ulonglong immediate_commit_timestamp =
4224 gtid_ev->immediate_commit_timestamp;
4225 2892 longlong original_commit_timestamp = gtid_ev->original_commit_timestamp;
4226
4227
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2892 times.
 2892 if (sidno < 0) {
4228 ✗ error = true;
4229 ✗ break;
4230 } else {
4231
2/4
✓ Branch 0 taken 2892 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2892 times.
 2892 if (retrieved_gtids->ensure_sidno(sidno) != RETURN_STATUS_OK) {
4232 ✗ error = true;
4233 ✗ break;
4234 } else {
4235 2892 Gtid gtid = {sidno, gtid_ev->get_gno()};
4236 /*
4237 As are updating the transaction boundary parser while reading
4238 GTIDs from relay log files to fill the Retrieved_Gtid_Set, we
4239 should not add the GTID here as we don't know if the transaction
4240 is complete on the relay log yet.
4241 */
4242
1/2
✓ Branch 0 taken 2892 times.
✗ Branch 1 not taken.
 2892 partial_trx->start(gtid, original_commit_timestamp,
4243 immediate_commit_timestamp);
4244 }
4245
3/8
✓ Branch 0 taken 2892 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2892 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2892 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 2892 DBUG_PRINT(
4246 "info",
4247 ("Found Gtid in relaylog file '%s': Gtid(%d, %" PRId64 ").",
4248 filename, sidno, gtid_ev->get_gno()));
4249 }
4250 2892 break;
4251 }
4252 14536 case binary_log::ANONYMOUS_GTID_LOG_EVENT:
4253 default:
4254 /*
4255 If we reached the end of a transaction after storing it's GTID
4256 in partial_trx structure, it is time to add this GTID to the
4257 retrieved_gtids set because the transaction is complete and there is
4258 no need for asking this transaction again.
4259 */
4260
2/2
✓ Branch 0 taken 4797 times.
✓ Branch 1 taken 9739 times.
 14536 if (trx_parser->is_not_inside_transaction()) {
4261
3/4
✓ Branch 0 taken 4797 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2889 times.
✓ Branch 3 taken 1908 times.
 4797 if (partial_trx->is_processing_trx_set()) {
4262 const Gtid *fully_retrieved_gtid;
4263
1/2
✓ Branch 0 taken 2889 times.
✗ Branch 1 not taken.
 2889 fully_retrieved_gtid = partial_trx->get_processing_trx_gtid();
4264
3/8
✓ Branch 0 taken 2889 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2889 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2889 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 2889 DBUG_PRINT("info", ("Adding Gtid to Retrieved_Gtid_Set as the "
4265 "transaction was completed at "
4266 "relaylog file '%s': Gtid(%d, %" PRId64 ").",
4267 filename, fully_retrieved_gtid->sidno,
4268 fully_retrieved_gtid->gno));
4269
1/2
✓ Branch 0 taken 2889 times.
✗ Branch 1 not taken.
 2889 retrieved_gtids->_add_gtid(*fully_retrieved_gtid);
4270 /*
4271 We don't need to update the last queued structure here. We just
4272 want to have the information about the partial transaction left in
4273 the relay log.
4274 */
4275
1/2
✓ Branch 0 taken 2889 times.
✗ Branch 1 not taken.
 2889 partial_trx->clear();
4276 }
4277 }
4278 14536 break;
4279 }
4280
1/2
✓ Branch 0 taken 39093 times.
✗ Branch 1 not taken.
 39093 delete ev;
4281 }
4282
4283
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9726 times.
 9726 if (relaylog_file_reader.has_fatal_error()) {
4284 // This is not a fatal error; the log may just be truncated.
4285 // @todo but what other errors could happen? IO error?
4286 ✗ LogErr(WARNING_LEVEL, ER_BINLOG_ERROR_READING_GTIDS_FROM_RELAY_LOG, -1);
4287 ✗ sql_print_warning(relaylog_file_reader.get_error_str());
4288 }
4289
4290 #ifndef NDEBUG
4291
8/16
✓ Branch 0 taken 9726 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9726 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9726 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9726 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9726 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 9726 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 9726 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 9726 times.
✗ Branch 15 not taken.
 9726 LogErr(INFORMATION_LEVEL, ER_BINLOG_EVENTS_READ_FROM_RELAY_LOG_INFO,
4292 event_counter, filename);
4293 #endif
4294
4295 9726 return error;
4296 9732 }
4297
4298 enum enum_read_gtids_from_binlog_status {
4299 GOT_GTIDS,
4300 GOT_PREVIOUS_GTIDS,
4301 NO_GTIDS,
4302 ERROR,
4303 TRUNCATED
4304 };
4305 /**
4306 Reads GTIDs from the given binlog file.
4307
4308 @param filename File to read from.
4309 @param all_gtids If not NULL, then the GTIDs from the
4310 Previous_gtids_log_event and from all Gtid_log_events are stored in
4311 this object.
4312 @param prev_gtids If not NULL, then the GTIDs from the
4313 Previous_gtids_log_events are stored in this object.
4314 @param first_gtid If not NULL, then the first GTID information from the
4315 file will be stored in this object.
4316 @param sid_map The sid_map object to use in the rpl_sidno generation
4317 of the Gtid_log_event. If lock is needed in the sid_map, the caller
4318 must hold it.
4319 @param verify_checksum Set to true to verify event checksums.
4320 @param is_relay_log Set to true, if filename is a Relay Log, false if it is a
4321 Binary Log.
4322 @retval GOT_GTIDS The file was successfully read and it contains
4323 both Gtid_log_events and Previous_gtids_log_events.
4324 This is only possible if either all_gtids or first_gtid are not null.
4325 @retval GOT_PREVIOUS_GTIDS The file was successfully read and it
4326 contains Previous_gtids_log_events but no Gtid_log_events.
4327 For binary logs, if no all_gtids and no first_gtid are specified,
4328 this function will be done right after reading the PREVIOUS_GTIDS
4329 regardless of the rest of the content of the binary log file.
4330 @retval NO_GTIDS The file was successfully read and it does not
4331 contain GTID events.
4332 @retval ERROR Out of memory, or IO error, or malformed event
4333 structure, or the file is malformed (e.g., contains Gtid_log_events
4334 but no Previous_gtids_log_event).
4335 @retval TRUNCATED The file was truncated before the end of the
4336 first Previous_gtids_log_event.
4337 */
4338 23150 static enum_read_gtids_from_binlog_status read_gtids_from_binlog(
4339 const char *filename, Gtid_set *all_gtids, Gtid_set *prev_gtids,
4340 Gtid *first_gtid, Sid_map *sid_map, bool verify_checksum,
4341 bool is_relay_log) {
4342
1/2
✓ Branch 0 taken 23150 times.
✗ Branch 1 not taken.
 23150 DBUG_TRACE;
4343
3/8
✓ Branch 0 taken 23150 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23150 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 23150 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 23150 DBUG_PRINT("info", ("Opening file %s", filename));
4344
4345 #ifndef NDEBUG
4346 23150 unsigned long event_counter = 0;
4347 /*
4348 We assert here that both all_gtids and prev_gtids, if specified,
4349 uses the same sid_map as the one passed as a parameter. This is just
4350 to ensure that, if the sid_map needed some lock and was locked by
4351 the caller, the lock applies to all the GTID sets this function is
4352 dealing with.
4353 */
4354
3/4
✓ Branch 0 taken 15889 times.
✓ Branch 1 taken 7261 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 15889 times.
 23150 if (all_gtids) assert(all_gtids->get_sid_map() == sid_map);
4355
3/4
✓ Branch 0 taken 8720 times.
✓ Branch 1 taken 14430 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8720 times.
 23150 if (prev_gtids) assert(prev_gtids->get_sid_map() == sid_map);
4356 #endif
4357
4358
1/2
✓ Branch 0 taken 23150 times.
✗ Branch 1 not taken.
 23150 Binlog_file_reader binlog_file_reader(verify_checksum);
4359
3/4
✓ Branch 0 taken 23150 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 23143 times.
 23150 if (binlog_file_reader.open(filename)) {
4360
9/18
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 7 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 7 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 7 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 7 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 7 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 7 times.
✗ Branch 17 not taken.
 7 LogErr(ERROR_LEVEL, ER_BINLOG_FILE_OPEN_FAILED,
4361 binlog_file_reader.get_error_str());
4362 /*
4363 We need to revisit the recovery procedure for relay log
4364 files. Currently, it is called after this routine.
4365 /Alfranio
4366 */
4367
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
 7 if (binlog_file_reader.get_error_type() ==
4368 Binlog_read_error::CANNOT_GET_FILE_PASSWORD)
4369 ✗ return ERROR;
4370 7 return TRUNCATED;
4371 }
4372
4373 23143 Log_event *ev = nullptr;
4374 23143 enum_read_gtids_from_binlog_status ret = NO_GTIDS;
4375 23143 bool done = false;
4376 23143 bool seen_first_gtid = false;
4377
7/8
✓ Branch 0 taken 34685154 times.
✓ Branch 1 taken 7964 times.
✓ Branch 2 taken 34685154 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 34669975 times.
✓ Branch 5 taken 15179 times.
✓ Branch 6 taken 34669975 times.
✓ Branch 7 taken 23143 times.
 34693118 while (!done && (ev = binlog_file_reader.read_event_object()) != nullptr) {
4378 #ifndef NDEBUG
4379 34669975 event_counter++;
4380 #endif
4381
3/10
✓ Branch 0 taken 34669975 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 34669975 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 34669975 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 34669975 DBUG_PRINT("info", ("Read event of type %s", ev->get_type_str()));
4382
5/5
✓ Branch 0 taken 25427 times.
✓ Branch 1 taken 23091 times.
✓ Branch 2 taken 8619 times.
✓ Branch 3 taken 2784459 times.
✓ Branch 4 taken 31828379 times.
 34669975 switch (ev->get_type_code()) {
4383 25427 case binary_log::FORMAT_DESCRIPTION_EVENT:
4384 case binary_log::ROTATE_EVENT:
4385 // do nothing; just accept this event and go to next
4386 25427 break;
4387 23091 case binary_log::PREVIOUS_GTIDS_LOG_EVENT: {
4388 23091 ret = GOT_PREVIOUS_GTIDS;
4389 // add events to sets
4390 23091 Previous_gtids_log_event *prev_gtids_ev =
4391
1/2
✓ Branch 0 taken 23091 times.
✗ Branch 1 not taken.
 23091 (Previous_gtids_log_event *)ev;
4392
5/8
✓ Branch 0 taken 15848 times.
✓ Branch 1 taken 7243 times.
✓ Branch 2 taken 15848 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15848 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 23091 times.
 23091 if (all_gtids != nullptr && prev_gtids_ev->add_to_set(all_gtids) != 0)
4393 ✗ ret = ERROR, done = true;
4394
3/4
✓ Branch 0 taken 8702 times.
✓ Branch 1 taken 14389 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 23091 times.
 31793 else if (prev_gtids != nullptr &&
4395
2/4
✓ Branch 0 taken 8702 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8702 times.
 8702 prev_gtids_ev->add_to_set(prev_gtids) != 0)
4396 ✗ ret = ERROR, done = true;
4397 #ifndef NDEBUG
4398
1/2
✓ Branch 0 taken 23091 times.
✗ Branch 1 not taken.
 23091 char *prev_buffer = prev_gtids_ev->get_str(nullptr, nullptr);
4399
3/8
✓ Branch 0 taken 23091 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23091 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 23091 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 23091 DBUG_PRINT("info", ("Got Previous_gtids from file '%s': Gtid_set='%s'.",
4400 filename, prev_buffer));
4401
1/2
✓ Branch 0 taken 23091 times.
✗ Branch 1 not taken.
 23091 my_free(prev_buffer);
4402 #endif
4403 /*
4404 If this is not a relay log, the previous_gtids were asked and no
4405 all_gtids neither first_gtid were asked, it is fine to consider the
4406 job as done.
4407 */
4408
8/8
✓ Branch 0 taken 13367 times.
✓ Branch 1 taken 9724 times.
✓ Branch 2 taken 8702 times.
✓ Branch 3 taken 4665 times.
✓ Branch 4 taken 7243 times.
✓ Branch 5 taken 1459 times.
✓ Branch 6 taken 4732 times.
✓ Branch 7 taken 2511 times.
 23091 if (!is_relay_log && prev_gtids != nullptr && all_gtids == nullptr &&
4409 first_gtid == nullptr)
4410 4732 done = true;
4411
2/14
✓ Branch 0 taken 23091 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 23091 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
 23091 DBUG_EXECUTE_IF("inject_fault_bug16502579", {
4412 DBUG_PRINT("debug", ("PREVIOUS_GTIDS_LOG_EVENT found. "
4413 "Injected ret=NO_GTIDS."));
4414 if (ret == GOT_PREVIOUS_GTIDS) {
4415 ret = NO_GTIDS;
4416 done = false;
4417 }
4418 });
4419 23091 break;
4420 }
4421 8619 case binary_log::GTID_LOG_EVENT: {
4422
2/2
✓ Branch 0 taken 2438 times.
✓ Branch 1 taken 6181 times.
 8619 if (ret != GOT_GTIDS) {
4423
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2438 times.
 2438 if (ret != GOT_PREVIOUS_GTIDS) {
4424 /*
4425 Since this routine is run on startup, there may not be a
4426 THD instance. Therefore, ER(X) cannot be used.
4427 */
4428 const char *msg_fmt =
4429 ✗ (current_thd != nullptr)
4430 ✗ ? ER_THD(current_thd, ER_BINLOG_LOGICAL_CORRUPTION)
4431 ✗ : ER_DEFAULT(ER_BINLOG_LOGICAL_CORRUPTION);
4432 ✗ my_printf_error(
4433 ER_BINLOG_LOGICAL_CORRUPTION, msg_fmt, MYF(0), filename,
4434 "The first global transaction identifier was read, but "
4435 "no other information regarding identifiers existing "
4436 "on the previous log files was found.");
4437 ✗ ret = ERROR, done = true;
4438 ✗ break;
4439 } else
4440 2438 ret = GOT_GTIDS;
4441 }
4442 /*
4443 When this is a relaylog, we just check if the relay log contains at
4444 least one Gtid_log_event, so that we can distinguish the return values
4445 GOT_GTID and GOT_PREVIOUS_GTIDS. We don't need to read anything else
4446 from the relay log.
4447 When this is a binary log, if all_gtids is requested (i.e., NOT NULL),
4448 we should continue to read all gtids. If just first_gtid was
4449 requested, we will be done after storing this Gtid_log_event info on
4450 it.
4451 */
4452
2/2
✓ Branch 0 taken 273 times.
✓ Branch 1 taken 8346 times.
 8619 if (is_relay_log) {
4453 273 ret = GOT_GTIDS, done = true;
4454 } else {
4455
1/2
✓ Branch 0 taken 8346 times.
✗ Branch 1 not taken.
 8346 Gtid_log_event *gtid_ev = (Gtid_log_event *)ev;
4456
1/2
✓ Branch 0 taken 8346 times.
✗ Branch 1 not taken.
 8346 rpl_sidno sidno = gtid_ev->get_sidno(sid_map);
4457
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8346 times.
 8346 if (sidno < 0)
4458 ✗ ret = ERROR, done = true;
4459 else {
4460
2/2
✓ Branch 0 taken 6574 times.
✓ Branch 1 taken 1772 times.
 8346 if (all_gtids) {
4461
2/4
✓ Branch 0 taken 6574 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6574 times.
 6574 if (all_gtids->ensure_sidno(sidno) != RETURN_STATUS_OK)
4462 ✗ ret = ERROR, done = true;
4463
1/2
✓ Branch 0 taken 6574 times.
✗ Branch 1 not taken.
 6574 all_gtids->_add_gtid(sidno, gtid_ev->get_gno());
4464
3/8
✓ Branch 0 taken 6574 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6574 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6574 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 6574 DBUG_PRINT("info",
4465 ("Got Gtid from file '%s': Gtid(%d, %" PRId64 ").",
4466 filename, sidno, gtid_ev->get_gno()));
4467 }
4468
4469 /* If the first GTID was requested, stores it */
4470
3/4
✓ Branch 0 taken 1772 times.
✓ Branch 1 taken 6574 times.
✓ Branch 2 taken 1772 times.
✗ Branch 3 not taken.
 8346 if (first_gtid && !seen_first_gtid) {
4471 1772 first_gtid->set(sidno, gtid_ev->get_gno());
4472 1772 seen_first_gtid = true;
4473 /* If the first_gtid was the only thing requested, we are done */
4474
1/2
✓ Branch 0 taken 1772 times.
✗ Branch 1 not taken.
 1772 if (all_gtids == nullptr) ret = GOT_GTIDS, done = true;
4475 }
4476 }
4477 }
4478 8619 break;
4479 }
4480 2784459 case binary_log::ANONYMOUS_GTID_LOG_EVENT: {
4481 /*
4482 When this is a relaylog, we just check if it contains
4483 at least one Anonymous_gtid_log_event after initialization
4484 (FDs, Rotates and PREVIOUS_GTIDS), so that we can distinguish the
4485 return values GOT_GTID and GOT_PREVIOUS_GTIDS.
4486 We don't need to read anything else from the relay log.
4487 */
4488
2/2
✓ Branch 0 taken 288 times.
✓ Branch 1 taken 2784171 times.
 2784459 if (is_relay_log) {
4489 288 ret = GOT_GTIDS;
4490 288 done = true;
4491 288 break;
4492 }
4493
5/6
✓ Branch 0 taken 1009253 times.
✓ Branch 1 taken 1774918 times.
✓ Branch 2 taken 144 times.
✓ Branch 3 taken 1009109 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 144 times.
 2784171 assert(prev_gtids == nullptr
4494 ? true
4495 : all_gtids != nullptr || first_gtid != nullptr);
4496 }
4497 [[fallthrough]];
4498 default:
4499 // if we found any other event type without finding a
4500 // previous_gtids_log_event, then the rest of this binlog
4501 // cannot contain gtids
4502
4/4
✓ Branch 0 taken 34586833 times.
✓ Branch 1 taken 25717 times.
✓ Branch 2 taken 40 times.
✓ Branch 3 taken 34586793 times.
 34612550 if (ret != GOT_GTIDS && ret != GOT_PREVIOUS_GTIDS) done = true;
4503 /*
4504 The GTIDs of the relaylog files will be handled later
4505 because of the possibility of transactions be spanned
4506 along distinct relaylog files.
4507 So, if we found an ordinary event without finding the
4508 GTID but we already found the PREVIOUS_GTIDS, this probably
4509 means that the event is from a transaction that started on
4510 previous relaylog file.
4511 */
4512
4/4
✓ Branch 0 taken 34586793 times.
✓ Branch 1 taken 25757 times.
✓ Branch 2 taken 859 times.
✓ Branch 3 taken 34585934 times.
 34612550 if (ret == GOT_PREVIOUS_GTIDS && is_relay_log) done = true;
4513 34612550 break;
4514 }
4515
1/2
✓ Branch 0 taken 34669975 times.
✗ Branch 1 not taken.
 34669975 delete ev;
4516
3/8
✓ Branch 0 taken 34669975 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 34669975 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 34669975 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 34669975 DBUG_PRINT("info", ("done=%d", done));
4517 }
4518
4519
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 23131 times.
 23143 if (binlog_file_reader.has_fatal_error()) {
4520 // This is not a fatal error; the log may just be truncated.
4521
4522 // @todo but what other errors could happen? IO error?
4523
8/16
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 12 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 12 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 12 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 12 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 12 times.
✗ Branch 15 not taken.
 12 LogErr(WARNING_LEVEL, ER_BINLOG_ERROR_READING_GTIDS_FROM_BINARY_LOG, -1);
4524
2/4
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
 12 sql_print_warning(binlog_file_reader.get_error_str());
4525 }
4526
4527
2/2
✓ Branch 0 taken 15883 times.
✓ Branch 1 taken 7260 times.
 23143 if (all_gtids)
4528
1/2
✓ Branch 0 taken 15883 times.
✗ Branch 1 not taken.
 15883 all_gtids->dbug_print("all_gtids");
4529 else
4530
3/8
✓ Branch 0 taken 7260 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7260 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 7260 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 7260 DBUG_PRINT("info", ("all_gtids==NULL"));
4531
2/2
✓ Branch 0 taken 8719 times.
✓ Branch 1 taken 14424 times.
 23143 if (prev_gtids)
4532
1/2
✓ Branch 0 taken 8719 times.
✗ Branch 1 not taken.
 8719 prev_gtids->dbug_print("prev_gtids");
4533 else
4534
3/8
✓ Branch 0 taken 14424 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14424 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14424 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 14424 DBUG_PRINT("info", ("prev_gtids==NULL"));
4535
2/2
✓ Branch 0 taken 20617 times.
✓ Branch 1 taken 2526 times.
 23143 if (first_gtid == nullptr)
4536
3/8
✓ Branch 0 taken 20617 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20617 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 20617 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 20617 DBUG_PRINT("info", ("first_gtid==NULL"));
4537
2/2
✓ Branch 0 taken 754 times.
✓ Branch 1 taken 1772 times.
 2526 else if (first_gtid->sidno == 0)
4538
3/8
✓ Branch 0 taken 754 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 754 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 754 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 754 DBUG_PRINT("info", ("first_gtid.sidno==0"));
4539 else
4540
1/2
✓ Branch 0 taken 1772 times.
✗ Branch 1 not taken.
 1772 first_gtid->dbug_print(sid_map, "first_gtid");
4541
4542
3/8
✓ Branch 0 taken 23143 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23143 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 23143 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 23143 DBUG_PRINT("info", ("returning %d", ret));
4543 #ifndef NDEBUG
4544
8/8
✓ Branch 0 taken 13417 times.
✓ Branch 1 taken 9726 times.
✓ Branch 2 taken 8719 times.
✓ Branch 3 taken 4698 times.
✓ Branch 4 taken 7260 times.
✓ Branch 5 taken 1459 times.
✓ Branch 6 taken 4734 times.
✓ Branch 7 taken 2526 times.
 23143 if (!is_relay_log && prev_gtids != nullptr && all_gtids == nullptr &&
4545 first_gtid == nullptr)
4546
8/16
✓ Branch 0 taken 4734 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4734 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4734 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4734 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4734 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4734 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 4734 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 4734 times.
✗ Branch 15 not taken.
 4734 LogErr(INFORMATION_LEVEL, ER_BINLOG_EVENTS_READ_FROM_BINLOG_INFO,
4547 event_counter, filename);
4548 #endif
4549 23143 return ret;
4550 23150 }
4551
4552 535 bool MYSQL_BIN_LOG::find_first_log(std::string &binlog_file_name,
4553 std::string &errmsg) {
4554
1/2
✓ Branch 0 taken 535 times.
✗ Branch 1 not taken.
 535 auto log_index = this->get_log_index();
4555
1/2
✓ Branch 0 taken 535 times.
✗ Branch 1 not taken.
 535 std::list<std::string> filename_list = log_index.second;
4556
4557 535 list<string>::iterator fit = filename_list.begin();
4558
1/2
✓ Branch 0 taken 535 times.
✗ Branch 1 not taken.
 535 if (fit != filename_list.end()) {
4559
1/2
✓ Branch 0 taken 535 times.
✗ Branch 1 not taken.
 535 binlog_file_name.assign(*fit);
4560 } else {
4561 ✗ errmsg.assign("Could not find the first log file name in the index file");
4562 ✗ return true;
4563 }
4564 535 return false;
4565 535 }
4566
4567 2229 bool MYSQL_BIN_LOG::find_first_log_not_in_gtid_set(char *binlog_file_name,
4568 const Gtid_set *gtid_set,
4569 Gtid *first_gtid,
4570 std::string &errmsg) {
4571
1/2
✓ Branch 0 taken 2229 times.
✗ Branch 1 not taken.
 2229 DBUG_TRACE;
4572 2229 LOG_INFO linfo;
4573
1/2
✓ Branch 0 taken 2229 times.
✗ Branch 1 not taken.
 2229 auto log_index = this->get_log_index();
4574
1/2
✓ Branch 0 taken 2229 times.
✗ Branch 1 not taken.
 2229 std::list<std::string> filename_list = log_index.second;
4575 2229 int error = log_index.first;
4576 2229 list<string>::reverse_iterator rit;
4577
1/2
✓ Branch 0 taken 2229 times.
✗ Branch 1 not taken.
 2229 Gtid_set binlog_previous_gtid_set{gtid_set->get_sid_map()};
4578
4579
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2229 times.
 2229 if (error != LOG_INFO_EOF) {
4580 ✗ errmsg.assign(
4581 "Failed to read the binary log index file while "
4582 "looking for the oldest binary log that contains any GTID "
4583 "that is not in the given gtid set");
4584 ✗ error = -1;
4585 ✗ goto end;
4586 }
4587
4588
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2229 times.
 2229 if (filename_list.empty()) {
4589 ✗ errmsg.assign(
4590 "Could not find first log file name in binary log index file "
4591 "while looking for the oldest binary log that contains any GTID "
4592 "that is not in the given gtid set");
4593 ✗ error = -2;
4594 ✗ goto end;
4595 }
4596
4597 /*
4598 Iterate over all the binary logs in reverse order, and read only
4599 the Previous_gtids_log_event, to find the first one, that is the
4600 subset of the given gtid set. Since every binary log begins with
4601 a Previous_gtids_log_event, that contains all GTIDs in all
4602 previous binary logs.
4603 We also ask for the first GTID in the binary log to know if we
4604 should send the FD event with the "created" field cleared or not.
4605 */
4606
3/8
✓ Branch 0 taken 2229 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2229 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2229 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 2229 DBUG_PRINT("info", ("Iterating backwards through binary logs, and reading "
4607 "only the Previous_gtids_log_event, to find the first "
4608 "one, that is the subset of the given gtid set."));
4609 2229 rit = filename_list.rbegin();
4610 2229 error = 0;
4611
3/4
✓ Branch 0 taken 2253 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2252 times.
✓ Branch 3 taken 1 times.
 2253 while (rit != filename_list.rend()) {
4612
1/2
✓ Branch 0 taken 2252 times.
✗ Branch 1 not taken.
 2252 binlog_previous_gtid_set.clear();
4613
1/2
✓ Branch 0 taken 2252 times.
✗ Branch 1 not taken.
 2252 const char *filename = rit->c_str();
4614
3/8
✓ Branch 0 taken 2252 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2252 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2252 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 2252 DBUG_PRINT("info",
4615 ("Read Previous_gtids_log_event from filename='%s'", filename));
4616
3/7
✓ Branch 0 taken 2252 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 2251 times.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.
 2252 switch (read_gtids_from_binlog(filename, nullptr, &binlog_previous_gtid_set,
4617 first_gtid,
4618 binlog_previous_gtid_set.get_sid_map(),
4619 2252 opt_source_verify_checksum, is_relay_log)) {
4620 ✗ case ERROR:
4621 ✗ errmsg.assign(
4622 "Error reading header of binary log while looking for "
4623 "the oldest binary log that contains any GTID that is not in "
4624 "the given gtid set");
4625 ✗ error = -3;
4626 ✗ goto end;
4627 ✗ case NO_GTIDS:
4628 ✗ errmsg.assign(
4629 "Found old binary log without GTIDs while looking for "
4630 "the oldest binary log that contains any GTID that is not in "
4631 "the given gtid set");
4632 ✗ error = -4;
4633 ✗ goto end;
4634 2251 case GOT_GTIDS:
4635 case GOT_PREVIOUS_GTIDS:
4636
3/4
✓ Branch 0 taken 2251 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2228 times.
✓ Branch 3 taken 23 times.
 2251 if (binlog_previous_gtid_set.is_subset(gtid_set)) {
4637 2228 strcpy(binlog_file_name, filename);
4638 /*
4639 Verify that the selected binlog is not the first binlog,
4640 */
4641
2/6
✓ Branch 0 taken 2228 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2228 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 2228 DBUG_EXECUTE_IF("replica_reconnect_with_gtid_set_executed",
4642 assert(strcmp(filename_list.begin()->c_str(),
4643 binlog_file_name) != 0););
4644 2228 goto end;
4645 }
4646 case TRUNCATED:
4647 24 break;
4648 }
4649
4650
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 rit++;
4651 }
4652
4653
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (rit == filename_list.rend()) {
4654
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 report_missing_gtids(&binlog_previous_gtid_set, gtid_set, errmsg);
4655 1 error = -5;
4656 }
4657
4658 ✗ end:
4659
5/10
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2228 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 2229 if (error) DBUG_PRINT("error", ("'%s'", errmsg.c_str()));
4660 2229 filename_list.clear();
4661
3/8
✓ Branch 0 taken 2229 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2229 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2229 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 2229 DBUG_PRINT("info", ("returning %d", error));
4662 2229 return error != 0 ? true : false;
4663 2229 }
4664
4665 12707 bool MYSQL_BIN_LOG::init_gtid_sets(Gtid_set *all_gtids, Gtid_set *lost_gtids,
4666 bool verify_checksum, bool need_lock,
4667 Transaction_boundary_parser *trx_parser,
4668 Gtid_monitoring_info *partial_trx,
4669 bool is_server_starting) {
4670
1/2
✓ Branch 0 taken 12707 times.
✗ Branch 1 not taken.
 12707 DBUG_TRACE;
4671
3/10
✓ Branch 0 taken 12707 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12707 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 12707 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 12707 DBUG_PRINT(
4672 "info",
4673 ("lost_gtids=%p; so we are recovering a %s log; is_relay_log=%d",
4674 lost_gtids, lost_gtids == nullptr ? "relay" : "binary", is_relay_log));
4675
4676 Checkable_rwlock *sid_lock =
4677
2/2
✓ Branch 0 taken 1276 times.
✓ Branch 1 taken 11431 times.
 12707 is_relay_log ? all_gtids->get_sid_map()->get_sid_lock() : global_sid_lock;
4678 /*
4679 If this is a relay log, we must have the IO thread Master_info trx_parser
4680 in order to correctly feed it with relay log events.
4681 */
4682 #ifndef NDEBUG
4683
2/2
✓ Branch 0 taken 1276 times.
✓ Branch 1 taken 11431 times.
 12707 if (is_relay_log) {
4684
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1276 times.
 1276 assert(trx_parser != nullptr);
4685
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1276 times.
 1276 assert(lost_gtids == nullptr);
4686 }
4687 #endif
4688
4689 /*
4690 Acquires the necessary locks to ensure that logs are not either
4691 removed or updated when we are reading from it.
4692 */
4693
2/2
✓ Branch 0 taken 12497 times.
✓ Branch 1 taken 210 times.
 12707 if (need_lock) {
4694 // We don't need LOCK_log if we are only going to read the initial
4695 // Prevoius_gtids_log_event and ignore the Gtid_log_events.
4696
2/4
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12497 times.
✗ Branch 3 not taken.
 12497 if (all_gtids != nullptr) mysql_mutex_lock(&LOCK_log);
4697
1/2
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
 12497 mysql_mutex_lock(&LOCK_index);
4698
1/2
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
 12497 sid_lock->wrlock();
4699 } else {
4700
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 210 times.
 210 if (all_gtids != nullptr) mysql_mutex_assert_owner(&LOCK_log);
4701 210 mysql_mutex_assert_owner(&LOCK_index);
4702
1/2
✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
 210 sid_lock->assert_some_wrlock();
4703 }
4704
4705 /* Initialize the sid_map to be used in read_gtids_from_binlog */
4706 12707 Sid_map *sid_map = nullptr;
4707
2/2
✓ Branch 0 taken 12497 times.
✓ Branch 1 taken 210 times.
 12707 if (all_gtids)
4708 12497 sid_map = all_gtids->get_sid_map();
4709
1/2
✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
 210 else if (lost_gtids)
4710 210 sid_map = lost_gtids->get_sid_map();
4711
4712 // Gather the set of files to be accessed.
4713
1/2
✓ Branch 0 taken 12707 times.
✗ Branch 1 not taken.
 12707 auto log_index = this->get_log_index(false);
4714
1/2
✓ Branch 0 taken 12707 times.
✗ Branch 1 not taken.
 12707 std::list<std::string> filename_list = log_index.second;
4715 12707 int error = log_index.first;
4716 12707 list<string>::iterator it;
4717 12707 list<string>::reverse_iterator rit;
4718 12707 bool reached_first_file = false;
4719
4720
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12707 times.
 12707 if (error != LOG_INFO_EOF) {
4721 ✗ DBUG_PRINT("error", ("Error reading %s index",
4722 is_relay_log ? "relaylog" : "binlog"));
4723 ✗ goto end;
4724 }
4725 /*
4726 On server starting, one new empty binlog file is created and
4727 its file name is put into index file before initializing
4728 GLOBAL.GTID_EXECUTED AND GLOBAL.GTID_PURGED, it is not the
4729 last binlog file before the server restarts, so we remove
4730 its file name from filename_list.
4731 */
4732
6/8
✓ Branch 0 taken 11221 times.
✓ Branch 1 taken 1486 times.
✓ Branch 2 taken 11221 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11221 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 11221 times.
✓ Branch 7 taken 1486 times.
 12707 if (is_server_starting && !is_relay_log && !filename_list.empty())
4733 11221 filename_list.pop_back();
4734
4735 12707 error = 0;
4736
2/2
✓ Branch 0 taken 12497 times.
✓ Branch 1 taken 210 times.
 12707 if (all_gtids != nullptr) {
4737
3/12
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12497 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 12497 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
 12497 DBUG_PRINT("info", ("Iterating backwards through %s logs, "
4738 "looking for the last %s log that contains "
4739 "a Previous_gtids_log_event.",
4740 is_relay_log ? "relay" : "binary",
4741 is_relay_log ? "relay" : "binary"));
4742 // Iterate over all files in reverse order until we find one that
4743 // contains a Previous_gtids_log_event.
4744 12497 rit = filename_list.rbegin();
4745 12497 bool can_stop_reading = false;
4746
1/2
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
 12497 reached_first_file = (rit == filename_list.rend());
4747
3/12
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12497 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 12497 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
 12497 DBUG_PRINT("info",
4748 ("filename='%s' reached_first_file=%d",
4749 reached_first_file ? "" : rit->c_str(), reached_first_file));
4750
4/4
✓ Branch 0 taken 21698 times.
✓ Branch 1 taken 6685 times.
✓ Branch 2 taken 15889 times.
✓ Branch 3 taken 5809 times.
 28383 while (!can_stop_reading && !reached_first_file) {
4751
1/2
✓ Branch 0 taken 15889 times.
✗ Branch 1 not taken.
 15889 const char *filename = rit->c_str();
4752
2/4
✓ Branch 0 taken 15889 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15889 times.
 15889 assert(rit != filename_list.rend());
4753
1/2
✓ Branch 0 taken 15889 times.
✗ Branch 1 not taken.
 15889 rit++;
4754
1/2
✓ Branch 0 taken 15889 times.
✗ Branch 1 not taken.
 15889 reached_first_file = (rit == filename_list.rend());
4755
3/8
✓ Branch 0 taken 15889 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15889 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15889 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 15889 DBUG_PRINT("info", ("filename='%s' can_stop_reading=%d "
4756 "reached_first_file=%d, ",
4757 filename, can_stop_reading, reached_first_file));
4758
5/8
✓ Branch 0 taken 15889 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 954 times.
✓ Branch 4 taken 14894 times.
✓ Branch 5 taken 35 times.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
 15889 switch (read_gtids_from_binlog(
4759 filename, all_gtids, reached_first_file ? lost_gtids : nullptr,
4760
2/2
✓ Branch 0 taken 2171 times.
✓ Branch 1 taken 13718 times.
 15889 nullptr /* first_gtid */, sid_map, verify_checksum, is_relay_log)) {
4761 ✗ case ERROR: {
4762 ✗ error = 1;
4763 ✗ goto end;
4764 }
4765 954 case GOT_GTIDS: {
4766 954 can_stop_reading = true;
4767 954 break;
4768 }
4769 14894 case GOT_PREVIOUS_GTIDS: {
4770 /*
4771 If this is a binlog file, it is enough to have GOT_PREVIOUS_GTIDS.
4772 If this is a relaylog file, we need to find at least one GTID to
4773 start parsing the relay log to add GTID of transactions that might
4774 have spanned in distinct relaylog files.
4775 */
4776
2/2
✓ Branch 0 taken 5731 times.
✓ Branch 1 taken 9163 times.
 14894 if (!is_relay_log) can_stop_reading = true;
4777 14894 break;
4778 }
4779 35 case NO_GTIDS: {
4780 /*
4781 Mysql server iterates backwards through binary logs, looking for
4782 the last binary log that contains a Previous_gtids_log_event for
4783 gathering the set of gtid_executed on server start. This may take
4784 very long time if it has many binary logs and almost all of them
4785 are out of filesystem cache. So if the binlog_gtid_simple_recovery
4786 is enabled, and the last binary log does not contain any GTID
4787 event, do not read any more binary logs, GLOBAL.GTID_EXECUTED and
4788 GLOBAL.GTID_PURGED should be empty in the case.
4789 */
4790
4/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2 times.
 35 if (binlog_gtid_simple_recovery && is_server_starting &&
4791
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 !is_relay_log) {
4792
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 3 assert(all_gtids->is_empty());
4793
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 3 assert(lost_gtids->is_empty());
4794 3 goto end;
4795 }
4796 [[fallthrough]];
4797 }
4798 case TRUNCATED: {
4799 38 break;
4800 }
4801 }
4802 }
4803
4804 /*
4805 If we use GTIDs and have partial transactions on the relay log,
4806 must check if it ends on next relay log files.
4807 We also need to feed the boundary parser with the rest of the
4808 relay log to put it in the correct state before receiving new
4809 events from the master in the case of GTID auto positioning be
4810 disabled.
4811 */
4812
6/6
✓ Branch 0 taken 1276 times.
✓ Branch 1 taken 11218 times.
✓ Branch 2 taken 1255 times.
✓ Branch 3 taken 21 times.
✓ Branch 4 taken 1255 times.
✓ Branch 5 taken 11239 times.
 12494 if (is_relay_log && filename_list.size() > 0) {
4813 /*
4814 Suppose the following relaylog:
4815
4816 rl-bin.000001 | rl-bin.000002 | rl-bin.000003 | rl-bin-000004
4817 ---------------+---------------+---------------+---------------
4818 PREV_GTIDS | PREV_GTIDS | PREV_GTIDS | PREV_GTIDS
4819 (empty) | (UUID:1) | (UUID:1) | (UUID:1)
4820 ---------------+---------------+---------------+---------------
4821 GTID(UUID:1) | QUERY(INSERT) | QUERY(INSERT) | XID
4822 ---------------+---------------+---------------+---------------
4823 QUERY(CREATE |
4824 TABLE t1 ...) |
4825 ---------------+
4826 GTID(UUID:2) |
4827 ---------------+
4828 QUERY(BEGIN) |
4829 ---------------+
4830
4831 As it is impossible to determine the current Retrieved_Gtid_Set by only
4832 looking to the PREVIOUS_GTIDS on the last relay log file, and scanning
4833 events on it, we tried to find a relay log file that contains at least
4834 one GTID event during the backwards search.
4835
4836 In the example, we will find a GTID only in rl-bin.000001, as the
4837 UUID:2 transaction was spanned across 4 relay log files.
4838
4839 The transaction spanning can be caused by "FLUSH RELAY LOGS" commands
4840 on slave while it is queuing the transaction.
4841
4842 So, in order to correctly add UUID:2 into Retrieved_Gtid_Set, we need
4843 to parse the relay log starting on the file we found the last GTID
4844 queued to know if the transaction was fully retrieved or not.
4845 */
4846
4847 /*
4848 Adjust the reverse iterator to point to the relaylog file we
4849 need to start parsing, as it was incremented after generating
4850 the relay log file name.
4851 */
4852
2/4
✓ Branch 0 taken 1255 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1255 times.
 1255 assert(rit != filename_list.rbegin());
4853
1/2
✓ Branch 0 taken 1255 times.
✗ Branch 1 not taken.
 1255 rit--;
4854
2/4
✓ Branch 0 taken 1255 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1255 times.
 1255 assert(rit != filename_list.rend());
4855 /* Reset the transaction parser before feeding it with events */
4856
1/2
✓ Branch 0 taken 1255 times.
✗ Branch 1 not taken.
 1255 trx_parser->reset();
4857
1/2
✓ Branch 0 taken 1255 times.
✗ Branch 1 not taken.
 1255 partial_trx->clear();
4858
4859
3/8
✓ Branch 0 taken 1255 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1255 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1255 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 1255 DBUG_PRINT("info", ("Iterating forwards through relay logs, "
4860 "updating the Retrieved_Gtid_Set and updating "
4861 "IO thread trx parser before start."));
4862
1/2
✓ Branch 0 taken 1255 times.
✗ Branch 1 not taken.
 1255 for (it = find(filename_list.begin(), filename_list.end(), *rit);
4863
2/2
✓ Branch 0 taken 9732 times.
✓ Branch 1 taken 1255 times.
 10987 it != filename_list.end(); it++) {
4864 9732 const char *filename = it->c_str();
4865
3/8
✓ Branch 0 taken 9732 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9732 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9732 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 9732 DBUG_PRINT("info", ("filename='%s'", filename));
4866
2/4
✓ Branch 0 taken 9732 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9732 times.
 9732 if (read_gtids_and_update_trx_parser_from_relaylog(
4867 filename, all_gtids, true, trx_parser, partial_trx)) {
4868 ✗ error = 1;
4869 ✗ goto end;
4870 }
4871 }
4872 }
4873 }
4874
4/4
✓ Branch 0 taken 1276 times.
✓ Branch 1 taken 11428 times.
✓ Branch 2 taken 6553 times.
✓ Branch 3 taken 4875 times.
 12704 if (lost_gtids != nullptr && !reached_first_file) {
4875 /*
4876 This branch is only reachable by a binary log. The relay log
4877 don't need to get lost_gtids information.
4878
4879 A 5.6 server sets GTID_PURGED by rotating the binary log.
4880
4881 A 5.6 server that had recently enabled GTIDs and set GTID_PURGED
4882 would have a sequence of binary logs like:
4883
4884 master-bin.N : No PREVIOUS_GTIDS (GTID wasn't enabled)
4885 master-bin.N+1: Has an empty PREVIOUS_GTIDS and a ROTATE
4886 (GTID was enabled on startup)
4887 master-bin.N+2: Has a PREVIOUS_GTIDS with the content set by a
4888 SET @@GLOBAL.GTID_PURGED + has GTIDs of some
4889 transactions.
4890
4891 If this 5.6 server be upgraded to 5.7 keeping its binary log files,
4892 this routine will have to find the first binary log that contains a
4893 PREVIOUS_GTIDS + a GTID event to ensure that the content of the
4894 GTID_PURGED will be correctly set (assuming binlog_gtid_simple_recovery
4895 is not enabled).
4896 */
4897
3/8
✓ Branch 0 taken 4875 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4875 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4875 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 4875 DBUG_PRINT("info", ("Iterating forwards through binary logs, looking for "
4898 "the first binary log that contains both a "
4899 "Previous_gtids_log_event and a Gtid_log_event."));
4900
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4875 times.
 4875 assert(!is_relay_log);
4901
2/2
✓ Branch 0 taken 5009 times.
✓ Branch 1 taken 15 times.
 5024 for (it = filename_list.begin(); it != filename_list.end(); it++) {
4902 /*
4903 We should pass a first_gtid to read_gtids_from_binlog when
4904 binlog_gtid_simple_recovery is disabled, or else it will return
4905 right after reading the PREVIOUS_GTIDS event to avoid stall on
4906 reading the whole binary log.
4907 */
4908 5009 Gtid first_gtid = {0, 0};
4909 5009 const char *filename = it->c_str();
4910
3/8
✓ Branch 0 taken 5009 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5009 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 5009 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 5009 DBUG_PRINT("info", ("filename='%s'", filename));
4911
3/7
✓ Branch 0 taken 5009 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 126 times.
✓ Branch 4 taken 4883 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 5009 switch (read_gtids_from_binlog(
4912 filename, nullptr, lost_gtids,
4913 binlog_gtid_simple_recovery ? nullptr : &first_gtid, sid_map,
4914
2/2
✓ Branch 0 taken 4734 times.
✓ Branch 1 taken 275 times.
 5009 verify_checksum, is_relay_log)) {
4915 ✗ case ERROR: {
4916 ✗ error = 1;
4917 [[fallthrough]];
4918 }
4919 126 case GOT_GTIDS: {
4920 4860 goto end;
4921 }
4922 4883 case NO_GTIDS:
4923 case GOT_PREVIOUS_GTIDS: {
4924 /*
4925 Mysql server iterates forwards through binary logs, looking for
4926 the first binary log that contains both Previous_gtids_log_event
4927 and gtid_log_event for gathering the set of gtid_purged on server
4928 start. It also iterates forwards through binary logs, looking for
4929 the first binary log that contains both Previous_gtids_log_event
4930 and gtid_log_event for gathering the set of gtid_purged when
4931 purging binary logs. This may take very long time if it has many
4932 binary logs and almost all of them are out of filesystem cache.
4933 So if the binlog_gtid_simple_recovery is enabled, we just
4934 initialize GLOBAL.GTID_PURGED from the first binary log, do not
4935 read any more binary logs.
4936 */
4937
2/2
✓ Branch 0 taken 4734 times.
✓ Branch 1 taken 149 times.
 4883 if (binlog_gtid_simple_recovery) goto end;
4938 [[fallthrough]];
4939 }
4940 case TRUNCATED: {
4941 149 break;
4942 }
4943 }
4944 }
4945 }
4946 7829 end:
4947
3/4
✓ Branch 0 taken 12497 times.
✓ Branch 1 taken 210 times.
✓ Branch 2 taken 12497 times.
✗ Branch 3 not taken.
 12707 if (all_gtids) all_gtids->dbug_print("all_gtids");
4948
3/4
✓ Branch 0 taken 11431 times.
✓ Branch 1 taken 1276 times.
✓ Branch 2 taken 11431 times.
✗ Branch 3 not taken.
 12707 if (lost_gtids) lost_gtids->dbug_print("lost_gtids");
4949
2/2
✓ Branch 0 taken 12497 times.
✓ Branch 1 taken 210 times.
 12707 if (need_lock) {
4950
1/2
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
 12497 sid_lock->unlock();
4951
1/2
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
 12497 mysql_mutex_unlock(&LOCK_index);
4952
2/4
✓ Branch 0 taken 12497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12497 times.
✗ Branch 3 not taken.
 12497 if (all_gtids != nullptr) mysql_mutex_unlock(&LOCK_log);
4953 }
4954 12707 filename_list.clear();
4955
3/8
✓ Branch 0 taken 12707 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12707 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 12707 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 12707 DBUG_PRINT("info", ("returning %d", error));
4956 12707 return error != 0 ? true : false;
4957 12707 }
4958
4959 /**
4960 Open a (new) binlog file.
4961
4962 - Open the log file and the index file. Register the new
4963 file name in it
4964 - When calling this when the file is in use, you must have a locks
4965 on LOCK_log and LOCK_index.
4966
4967 @retval
4968 0 ok
4969 @retval
4970 1 error
4971 */
4972
4973 84445 bool MYSQL_BIN_LOG::open_binlog(
4974 const char *log_name, const char *new_name, ulong max_size_arg,
4975 bool null_created_arg, bool need_lock_index, bool need_sid_lock,
4976 Format_description_log_event *extra_description_event,
4977 uint32 new_index_number) {
4978 // lock_index must be acquired *before* sid_lock.
4979
3/4
✓ Branch 0 taken 27126 times.
✓ Branch 1 taken 57319 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 27126 times.
 84445 assert(need_sid_lock || !need_lock_index);
4980
1/2
✓ Branch 0 taken 84445 times.
✗ Branch 1 not taken.
 84445 DBUG_TRACE;
4981
3/8
✓ Branch 0 taken 84445 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84445 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 84445 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 84445 DBUG_PRINT("enter", ("base filename: %s", log_name));
4982
4983 84445 mysql_mutex_assert_owner(get_log_lock());
4984
4985
3/4
✓ Branch 0 taken 84445 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 84442 times.
 84445 if (init_and_set_log_file_name(log_name, new_name, new_index_number)) {
4986
8/16
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
 3 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_GENERATE_NEW_FILE_NAME);
4987 3 return true;
4988 }
4989
4990
3/8
✓ Branch 0 taken 84442 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84442 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 84442 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 84442 DBUG_PRINT("info", ("generated filename: %s", log_file_name));
4991
4992
1/2
✓ Branch 0 taken 84442 times.
✗ Branch 1 not taken.
 84442 if (open_purge_index_file(true) ||
4993
8/12
✓ Branch 0 taken 84442 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84442 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 84442 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 84441 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 84440 times.
✓ Branch 9 taken 1 times.
✓ Branch 10 taken 6 times.
✓ Branch 11 taken 84435 times.
 168882 register_create_index_entry(log_file_name) || sync_purge_index_file() ||
4994
3/4
✓ Branch 0 taken 84440 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 84435 times.
 84440 DBUG_EVALUATE_IF("fault_injection_registering_index", 1, 0)) {
4995 /**
4996 @todo: although this was introduced to appease valgrind
4997 when injecting emulated faults using fault_injection_registering_index
4998 it may be good to consider what actually happens when
4999 open_purge_index_file succeeds but register or sync fails.
5000
5001 Perhaps we might need the code below in MYSQL_BIN_LOG::cleanup
5002 for "real life" purposes as well?
5003 */
5004
6/10
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 5 times.
✗ Branch 9 not taken.
 6 DBUG_EXECUTE_IF("fault_injection_registering_index", {
5005 if (my_b_inited(&purge_index_file)) {
5006 end_io_cache(&purge_index_file);
5007 my_close(purge_index_file.file, MYF(0));
5008 }
5009 });
5010
5011
8/16
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6 times.
✗ Branch 15 not taken.
 6 LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_SYNC_INDEX_FILE_IN_OPEN);
5012 6 return true;
5013 }
5014
4/6
✓ Branch 0 taken 84435 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 84432 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 84435 DBUG_EXECUTE_IF("crash_create_non_critical_before_update_index",
5015 DBUG_SUICIDE(););
5016
5017 84432 write_error = false;
5018
5019 /* open the main log file */
5020
3/4
✓ Branch 0 taken 84432 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 84431 times.
 84432 if (open(m_key_file_log, log_name, new_name, new_index_number)) {
5021
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 close_purge_index_file();
5022 1 return true; /* all warnings issued */
5023 }
5024
5025 84431 max_size = max_size_arg;
5026
5027 84431 bool write_file_name_to_index_file = false;
5028
5029 /* This must be before goto err. */
5030 #ifndef NDEBUG
5031 84431 binary_log_debug::debug_pretend_version_50034_in_binlog =
5032
1/2
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
 84431 DBUG_EVALUATE_IF("pretend_version_50034_in_binlog", true, false);
5033 #endif
5034
1/2
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
 84431 Format_description_log_event s;
5035
5036
1/2
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
 84431 if (m_binlog_file->is_empty()) {
5037 /*
5038 The binary log file was empty (probably newly created)
5039 This is the normal case and happens when the user doesn't specify
5040 an extension for the binary log files.
5041 In this case we write a standard header to it.
5042 */
5043
2/4
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84431 times.
 84431 if (m_binlog_file->write(pointer_cast<const uchar *>(BINLOG_MAGIC),
5044 BIN_LOG_HEADER_SIZE))
5045 ✗ goto err;
5046 84431 bytes_written += BIN_LOG_HEADER_SIZE;
5047 84431 write_file_name_to_index_file = true;
5048 }
5049
5050 /*
5051 don't set LOG_EVENT_BINLOG_IN_USE_F for the relay log
5052 */
5053
2/2
✓ Branch 0 taken 30662 times.
✓ Branch 1 taken 53769 times.
 84431 if (!is_relay_log) {
5054 30662 s.common_header->flags |= LOG_EVENT_BINLOG_IN_USE_F;
5055 }
5056
5057
2/2
✓ Branch 0 taken 53769 times.
✓ Branch 1 taken 30662 times.
 84431 if (is_relay_log) {
5058 /* relay-log */
5059
2/2
✓ Branch 0 taken 6642 times.
✓ Branch 1 taken 47127 times.
 53769 if (relay_log_checksum_alg == binary_log::BINLOG_CHECKSUM_ALG_UNDEF) {
5060 /* inherit master's A descriptor if one has been received */
5061
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6642 times.
 6642 if (opt_replica_sql_verify_checksum == 0)
5062 /* otherwise use slave's local preference of RL events verification */
5063 ✗ relay_log_checksum_alg = binary_log::BINLOG_CHECKSUM_ALG_OFF;
5064 else
5065 6642 relay_log_checksum_alg =
5066 6642 static_cast<enum_binlog_checksum_alg>(binlog_checksum_options);
5067 }
5068 }
5069
5070
2/4
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84431 times.
 84431 if (!s.is_valid()) goto err;
5071 84431 s.dont_set_created = null_created_arg;
5072 /* Set LOG_EVENT_RELAY_LOG_F flag for relay log's FD */
5073
2/2
✓ Branch 0 taken 53769 times.
✓ Branch 1 taken 30662 times.
 84431 if (is_relay_log) s.set_relay_log_event();
5074
2/4
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84431 times.
 84431 if (write_event_to_binlog(&s)) goto err;
5075
5076 /*
5077 We need to revisit this code and improve it.
5078 See further comments in the mysqld.
5079 /Alfranio
5080 */
5081
3/4
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 71717 times.
✓ Branch 3 taken 12714 times.
 84431 if (current_thd) {
5082 71717 Checkable_rwlock *sid_lock = nullptr;
5083
1/2
✓ Branch 0 taken 71717 times.
✗ Branch 1 not taken.
 71717 Gtid_set logged_gtids_binlog(global_sid_map, global_sid_lock);
5084 Gtid_set *previous_logged_gtids;
5085
5086
2/2
✓ Branch 0 taken 52279 times.
✓ Branch 1 taken 19438 times.
 71717 if (is_relay_log) {
5087 52279 previous_logged_gtids = previous_gtid_set_relaylog;
5088 52279 sid_lock = previous_gtid_set_relaylog->get_sid_map()->get_sid_lock();
5089 } else {
5090 19438 previous_logged_gtids = &logged_gtids_binlog;
5091 19438 sid_lock = global_sid_lock;
5092 }
5093
5094
2/2
✓ Branch 0 taken 44592 times.
✓ Branch 1 taken 27125 times.
 71717 if (need_sid_lock)
5095
1/2
✓ Branch 0 taken 44592 times.
✗ Branch 1 not taken.
 44592 sid_lock->wrlock();
5096 else
5097
1/2
✓ Branch 0 taken 27125 times.
✗ Branch 1 not taken.
 27125 sid_lock->assert_some_wrlock();
5098
5099
2/2
✓ Branch 0 taken 19438 times.
✓ Branch 1 taken 52279 times.
 71717 if (!is_relay_log) {
5100 19438 const Gtid_set *executed_gtids = gtid_state->get_executed_gtids();
5101 const Gtid_set *gtids_only_in_table =
5102 19438 gtid_state->get_gtids_only_in_table();
5103 /* logged_gtids_binlog= executed_gtids - gtids_only_in_table */
5104
2/4
✓ Branch 0 taken 19438 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19438 times.
 19438 if (logged_gtids_binlog.add_gtid_set(executed_gtids) !=
5105 RETURN_STATUS_OK) {
5106 ✗ if (need_sid_lock) sid_lock->unlock();
5107 ✗ goto err;
5108 }
5109
1/2
✓ Branch 0 taken 19438 times.
✗ Branch 1 not taken.
 19438 logged_gtids_binlog.remove_gtid_set(gtids_only_in_table);
5110 }
5111
3/10
✓ Branch 0 taken 71717 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 71717 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 71717 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 71717 DBUG_PRINT("info", ("Generating PREVIOUS_GTIDS for %s file.",
5112 is_relay_log ? "relaylog" : "binlog"));
5113
1/2
✓ Branch 0 taken 71717 times.
✗ Branch 1 not taken.
 71717 Previous_gtids_log_event prev_gtids_ev(previous_logged_gtids);
5114
2/2
✓ Branch 0 taken 52279 times.
✓ Branch 1 taken 19438 times.
 71717 if (is_relay_log) prev_gtids_ev.set_relay_log_event();
5115
3/4
✓ Branch 0 taken 44592 times.
✓ Branch 1 taken 27125 times.
✓ Branch 2 taken 44592 times.
✗ Branch 3 not taken.
 71717 if (need_sid_lock) sid_lock->unlock();
5116
2/4
✓ Branch 0 taken 71717 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 71717 times.
 71717 if (write_event_to_binlog(&prev_gtids_ev)) goto err;
5117
2/4
✓ Branch 0 taken 71717 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 71717 times.
✗ Branch 3 not taken.
 71717 } else // !(current_thd)
5118 {
5119 /*
5120 If the slave was configured before server restart, the server will
5121 generate a new relay log file without having current_thd, but this
5122 new relay log file must have a PREVIOUS_GTIDS event as we now
5123 generate the PREVIOUS_GTIDS event always.
5124
5125 This is only needed for relay log files because the server will add
5126 the PREVIOUS_GTIDS of binary logs (when current_thd==NULL) after
5127 server's GTID initialization.
5128
5129 During server's startup at mysqld_main(), from the binary/relay log
5130 initialization point of view, it will:
5131 1) Call init_server_components() that will generate a new binary log
5132 file but won't write the PREVIOUS_GTIDS event yet;
5133 2) Initialize server's GTIDs;
5134 3) Write the binary log PREVIOUS_GTIDS;
5135 4) Call init_replica() in where the new relay log file will be created
5136 after initializing relay log's Retrieved_Gtid_Set;
5137 */
5138
2/2
✓ Branch 0 taken 1490 times.
✓ Branch 1 taken 11224 times.
 12714 if (is_relay_log) {
5139 Sid_map *previous_gtid_sid_map =
5140 1490 previous_gtid_set_relaylog->get_sid_map();
5141 1490 Checkable_rwlock *sid_lock = previous_gtid_sid_map->get_sid_lock();
5142
5143
1/2
✓ Branch 0 taken 1490 times.
✗ Branch 1 not taken.
 1490 if (need_sid_lock)
5144
1/2
✓ Branch 0 taken 1490 times.
✗ Branch 1 not taken.
 1490 sid_lock->wrlock();
5145 else
5146 ✗ sid_lock->assert_some_wrlock(); /* purecov: inspected */
5147
5148
3/8
✓ Branch 0 taken 1490 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1490 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1490 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 1490 DBUG_PRINT("info", ("Generating PREVIOUS_GTIDS for relaylog file."));
5149
1/2
✓ Branch 0 taken 1490 times.
✗ Branch 1 not taken.
 1490 Previous_gtids_log_event prev_gtids_ev(previous_gtid_set_relaylog);
5150 1490 prev_gtids_ev.set_relay_log_event();
5151
5152
2/4
✓ Branch 0 taken 1490 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1490 times.
✗ Branch 3 not taken.
 1490 if (need_sid_lock) sid_lock->unlock();
5153
5154
2/4
✓ Branch 0 taken 1490 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1490 times.
 1490 if (write_event_to_binlog(&prev_gtids_ev)) goto err;
5155
1/2
✓ Branch 0 taken 1490 times.
✗ Branch 1 not taken.
 1490 }
5156 }
5157
2/2
✓ Branch 0 taken 5559 times.
✓ Branch 1 taken 78872 times.
 84431 if (extra_description_event) {
5158 /*
5159 This is a relay log written to by the I/O slave thread.
5160 Write the event so that others can later know the format of this relay
5161 log.
5162 Note that this event is very close to the original event from the
5163 master (it has binlog version of the master, event types of the
5164 master), so this is suitable to parse the next relay log's event. It
5165 has been produced by
5166 Format_description_log_event::Format_description_log_event(char* buf,).
5167 Why don't we want to write the mi_description_event if this
5168 event is for format<4 (3.23 or 4.x): this is because in that case, the
5169 mi_description_event describes the data received from the
5170 master, but not the data written to the relay log (*conversion*),
5171 which is in format 4 (slave's).
5172 */
5173 /*
5174 Set 'created' to 0, so that in next relay logs this event does not
5175 trigger cleaning actions on the slave in
5176 Format_description_log_event::apply_event_impl().
5177 */
5178 5559 extra_description_event->created = 0;
5179 /* Don't set log_pos in event header */
5180 5559 extra_description_event->set_artificial_event();
5181
2/4
✓ Branch 0 taken 5559 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5559 times.
 5559 if (binary_event_serialize(extra_description_event, m_binlog_file))
5182 ✗ goto err;
5183 5559 bytes_written += extra_description_event->common_header->data_written;
5184 }
5185
2/4
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84431 times.
 84431 if (m_binlog_file->flush_and_sync()) goto err;
5186
5187
1/2
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
 84431 if (write_file_name_to_index_file) {
5188
4/6
✓ Branch 0 taken 84431 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 84428 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 84431 DBUG_EXECUTE_IF("crash_create_critical_before_update_index",
5189 DBUG_SUICIDE(););
5190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84428 times.
 84428 assert(my_b_inited(&index_file) != 0);
5191
5192 /*
5193 The new log file name is appended into crash safe index file after
5194 all the content of index file is copied into the crash safe index
5195 file. Then move the crash safe index file to index file.
5196 */
5197
4/6
✓ Branch 0 taken 84428 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 84427 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 84428 DBUG_EXECUTE_IF("simulate_disk_full_on_open_binlog",
5198 { DBUG_SET("+d,simulate_no_free_space_error"); });
5199
5/6
✓ Branch 0 taken 84428 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84424 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 11 times.
✓ Branch 5 taken 84411 times.
 168846 if (DBUG_EVALUATE_IF("fault_injection_updating_index", 1, 0) ||
5200
3/4
✓ Branch 0 taken 84418 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 84411 times.
 84424 add_log_to_index((uchar *)log_file_name, strlen(log_file_name),
5201 need_lock_index)) {
5202
6/10
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
 11 DBUG_EXECUTE_IF("simulate_disk_full_on_open_binlog", {
5203 DBUG_SET("-d,simulate_file_write_error");
5204 DBUG_SET("-d,simulate_no_free_space_error");
5205 DBUG_SET("-d,simulate_disk_full_on_open_binlog");
5206 });
5207 11 goto err;
5208 }
5209
5210
4/6
✓ Branch 0 taken 84411 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 84408 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 84411 DBUG_EXECUTE_IF("crash_create_after_update_index", DBUG_SUICIDE(););
5211 }
5212
5213 84408 atomic_log_state = LOG_OPENED;
5214 /*
5215 At every rotate memorize the last transaction counter state to use it as
5216 offset at logging the transaction logical timestamps.
5217 */
5218
1/2
✓ Branch 0 taken 84408 times.
✗ Branch 1 not taken.
 84408 m_dependency_tracker.rotate();
5219
5220
1/2
✓ Branch 0 taken 84408 times.
✗ Branch 1 not taken.
 84408 close_purge_index_file();
5221
5222
1/2
✓ Branch 0 taken 84408 times.
✗ Branch 1 not taken.
 84408 update_binlog_end_pos();
5223 84408 return false;
5224
5225 11 err:
5226
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
 11 if (is_inited_purge_index_file())
5227
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 purge_index_entry(nullptr, nullptr, need_lock_index);
5228
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 close_purge_index_file();
5229
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (binlog_error_action == ABORT_SERVER) {
5230 ✗ exec_binlog_error_action_abort(
5231 "Either disk is full, file system is read only or "
5232 "there was an encryption error while opening the binlog. "
5233 "Aborting the server.");
5234 } else {
5235
9/18
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 11 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 11 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 11 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 11 times.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✓ Branch 15 taken 11 times.
✓ Branch 16 taken 11 times.
✗ Branch 17 not taken.
 11 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_USE_FOR_LOGGING,
5236 (new_name) ? new_name : name, errno);
5237
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 close(LOG_CLOSE_INDEX, false, need_lock_index);
5238 }
5239 11 return true;
5240 84429 }
5241
5242 /**
5243 Move crash safe index file to index file.
5244
5245 @param need_lock_index If true, LOCK_index will be acquired;
5246 otherwise it should already be held.
5247
5248 @retval 0 ok
5249 @retval -1 error
5250 */
5251 108993 int MYSQL_BIN_LOG::move_crash_safe_index_file_to_index_file(
5252 bool need_lock_index) {
5253 108993 int error = 0;
5254 108993 File fd = -1;
5255
1/2
✓ Branch 0 taken 108993 times.
✗ Branch 1 not taken.
 108993 DBUG_TRACE;
5256 108993 int failure_trials = MYSQL_BIN_LOG::MAX_RETRIES_FOR_DELETE_RENAME_FAILURE;
5257 108993 bool file_rename_status = false, file_delete_status = false;
5258
1/2
✓ Branch 0 taken 108993 times.
✗ Branch 1 not taken.
 108993 THD *thd = current_thd;
5259
5260
2/2
✓ Branch 0 taken 23364 times.
✓ Branch 1 taken 85629 times.
 108993 if (need_lock_index)
5261
1/2
✓ Branch 0 taken 23364 times.
✗ Branch 1 not taken.
 23364 mysql_mutex_lock(&LOCK_index);
5262 else
5263 85629 mysql_mutex_assert_owner(&LOCK_index);
5264
5265
1/2
✓ Branch 0 taken 108993 times.
✗ Branch 1 not taken.
 108993 if (my_b_inited(&index_file)) {
5266
1/2
✓ Branch 0 taken 108993 times.
✗ Branch 1 not taken.
 108993 end_io_cache(&index_file);
5267
2/4
✓ Branch 0 taken 108993 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 108993 times.
 108993 if (mysql_file_close(index_file.file, MYF(0)) < 0) {
5268 ✗ error = -1;
5269 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_CLOSE_INDEX_FILE_WHILE_REBUILDING,
5270 index_file_name);
5271 /*
5272 Delete Crash safe index file here and recover the binlog.index
5273 state(index_file io_cache) from old binlog.index content.
5274 */
5275 ✗ mysql_file_delete(key_file_binlog_index, crash_safe_index_file_name,
5276 MYF(0));
5277
5278 ✗ goto recoverable_err;
5279 }
5280
5281 /*
5282 Sometimes an outsider can lock index files for temporary viewing
5283 purpose. For eg: MEB locks binlog.index/relaylog.index to view
5284 the content of the file. During that small period of time, deletion
5285 of the file is not possible on some platforms(Eg: Windows)
5286 Server should retry the delete operation for few times instead of
5287 panicking immediately.
5288 */
5289
3/4
✓ Branch 0 taken 109005 times.
✓ Branch 1 taken 108984 times.
✓ Branch 2 taken 109005 times.
✗ Branch 3 not taken.
 217989 while ((file_delete_status == false) && (failure_trials > 0)) {
5290
3/4
✓ Branch 0 taken 109005 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 108996 times.
 109005 if (DBUG_EVALUATE_IF("force_index_file_delete_failure", 1, 0)) break;
5291
5292
9/12
✓ Branch 0 taken 108996 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 108981 times.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 12 times.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 15 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✓ Branch 11 taken 12 times.
 108996 DBUG_EXECUTE_IF("simulate_index_file_delete_failure", {
5293 /* This simulation causes the delete to fail */
5294 static char first_char = index_file_name[0];
5295 index_file_name[0] = 0;
5296 sql_print_information("Retrying delete");
5297 if (failure_trials == 1) index_file_name[0] = first_char;
5298 };);
5299
1/2
✓ Branch 0 taken 108996 times.
✗ Branch 1 not taken.
 108996 file_delete_status = !(mysql_file_delete(key_file_binlog_index,
5300 index_file_name, MYF(MY_WME)));
5301 108996 --failure_trials;
5302
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 108984 times.
 108996 if (!file_delete_status) {
5303
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
 12 my_sleep(1000);
5304 /* Clear the error before retrying. */
5305
2/4
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
 12 if (failure_trials > 0) thd->clear_error();
5306 }
5307 }
5308
5309
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 108984 times.
 108993 if (!file_delete_status) {
5310 9 error = -1;
5311
8/16
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 9 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 9 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 9 times.
✗ Branch 15 not taken.
 9 LogErr(ERROR_LEVEL,
5312 ER_BINLOG_FAILED_TO_DELETE_INDEX_FILE_WHILE_REBUILDING,
5313 index_file_name);
5314 /*
5315 Delete Crash safe file index file here and recover the binlog.index
5316 state(index_file io_cache) from old binlog.index content.
5317 */
5318
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 mysql_file_delete(key_file_binlog_index, crash_safe_index_file_name,
5319 MYF(0));
5320
5321 9 goto recoverable_err;
5322 }
5323 }
5324
5325
4/6
✓ Branch 0 taken 108983 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 108977 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
 108984 DBUG_EXECUTE_IF("crash_create_before_rename_index_file", DBUG_SUICIDE(););
5326 /*
5327 Sometimes an outsider can lock index files for temporary viewing
5328 purpose. For eg: MEB locks binlog.index/relaylog.index to view
5329 the content of the file. During that small period of time, rename
5330 of the file is not possible on some platforms(Eg: Windows)
5331 Server should retry the rename operation for few times instead of panicking
5332 immediately.
5333 */
5334 108977 failure_trials = MYSQL_BIN_LOG::MAX_RETRIES_FOR_DELETE_RENAME_FAILURE;
5335
3/4
✓ Branch 0 taken 108989 times.
✓ Branch 1 taken 108978 times.
✓ Branch 2 taken 108989 times.
✗ Branch 3 not taken.
 217967 while ((file_rename_status == false) && (failure_trials > 0)) {
5336
9/12
✓ Branch 0 taken 108990 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 108975 times.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 12 times.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 15 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✓ Branch 11 taken 12 times.
 108989 DBUG_EXECUTE_IF("simulate_crash_safe_index_file_rename_failure", {
5337 /* This simulation causes the rename to fail */
5338 static char first_char = index_file_name[0];
5339 index_file_name[0] = 0;
5340 sql_print_information("Retrying rename");
5341 if (failure_trials == 1) index_file_name[0] = first_char;
5342 };);
5343 108990 file_rename_status =
5344
1/2
✓ Branch 0 taken 108990 times.
✗ Branch 1 not taken.
 108990 !(my_rename(crash_safe_index_file_name, index_file_name, MYF(MY_WME)));
5345 108990 --failure_trials;
5346
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 108978 times.
 108990 if (!file_rename_status) {
5347
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
 12 my_sleep(1000);
5348 /* Clear the error before retrying. */
5349
2/4
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
 12 if (failure_trials > 0) thd->clear_error();
5350 }
5351 }
5352
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108978 times.
 108978 if (!file_rename_status) {
5353 ✗ error = -1;
5354 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_RENAME_INDEX_FILE_WHILE_REBUILDING,
5355 index_file_name);
5356 ✗ goto fatal_err;
5357 }
5358
4/6
✓ Branch 0 taken 108978 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 108972 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
 108978 DBUG_EXECUTE_IF("crash_create_after_rename_index_file", DBUG_SUICIDE(););
5359
5360 108972 recoverable_err:
5361
1/2
✓ Branch 0 taken 108981 times.
✗ Branch 1 not taken.
 108981 if ((fd = mysql_file_open(key_file_binlog_index, index_file_name,
5362 108981 O_RDWR | O_CREAT, MYF(MY_WME))) < 0 ||
5363
4/8
✓ Branch 0 taken 108981 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 108981 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 108981 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 108981 times.
 217962 mysql_file_sync(fd, MYF(MY_WME)) ||
5364
3/6
✓ Branch 0 taken 108981 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 108981 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 108981 times.
 108981 init_io_cache_ext(&index_file, fd, IO_SIZE, READ_CACHE,
5365 mysql_file_seek(fd, 0L, MY_SEEK_END, MYF(0)), false,
5366 MYF(MY_WME | MY_WAIT_IF_FULL),
5367 key_file_binlog_index_cache)) {
5368 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_OPEN_INDEX_FILE_AFTER_REBUILDING,
5369 index_file_name);
5370 ✗ goto fatal_err;
5371 }
5372
5373
3/4
✓ Branch 0 taken 23364 times.
✓ Branch 1 taken 85617 times.
✓ Branch 2 taken 23364 times.
✗ Branch 3 not taken.
 108981 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
5374 108981 return error;
5375
5376 ✗ fatal_err:
5377 /*
5378 This situation is very very rare to happen (unless there is some serious
5379 memory related issues like OOM) and should be treated as fatal error.
5380 Hence it is better to bring down the server without respecting
5381 'binlog_error_action' value here.
5382 */
5383 ✗ exec_binlog_error_action_abort(
5384 "MySQL server failed to update the "
5385 "binlog.index file's content properly. "
5386 "It might not be in sync with available "
5387 "binlogs and the binlog.index file state is in "
5388 "unrecoverable state. Aborting the server.");
5389 /*
5390 Server is aborted in the above function.
5391 This is dead code to make compiler happy.
5392 */
5393 ✗ return error;
5394 108981 }
5395
5396 /**
5397 Append log file name to index file.
5398
5399 - To make crash safe, we copy all the content of index file
5400 to crash safe index file firstly and then append the log
5401 file name to the crash safe index file. Finally move the
5402 crash safe index file to index file.
5403
5404 @retval
5405 0 ok
5406 @retval
5407 -1 error
5408 */
5409 84424 int MYSQL_BIN_LOG::add_log_to_index(uchar *log_name, size_t log_name_len,
5410 bool need_lock_index) {
5411
1/2
✓ Branch 0 taken 84424 times.
✗ Branch 1 not taken.
 84424 DBUG_TRACE;
5412
5413
2/4
✓ Branch 0 taken 84424 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84424 times.
 84424 if (open_crash_safe_index_file()) {
5414 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_TMP_INDEX,
5415 "MYSQL_BIN_LOG::add_log_to_index");
5416 ✗ goto err;
5417 }
5418
5419
3/4
✓ Branch 0 taken 84424 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 84423 times.
 84424 if (copy_file(&index_file, &crash_safe_index_file, 0)) {
5420
8/16
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
 1 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_COPY_INDEX_TO_TMP,
5421 "MYSQL_BIN_LOG::add_log_to_index");
5422 1 goto err;
5423 }
5424
5425
1/2
✓ Branch 0 taken 84423 times.
✗ Branch 1 not taken.
 84423 if (my_b_write(&crash_safe_index_file, log_name, log_name_len) ||
5426
2/4
✓ Branch 0 taken 84423 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84423 times.
✗ Branch 3 not taken.
 84423 my_b_write(&crash_safe_index_file, pointer_cast<const uchar *>("\n"),
5427 84423 1) ||
5428
4/8
✓ Branch 0 taken 84423 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84423 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 84423 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 84423 times.
 253269 flush_io_cache(&crash_safe_index_file) ||
5429
2/4
✓ Branch 0 taken 84423 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84423 times.
 84423 mysql_file_sync(crash_safe_index_file.file, MYF(MY_WME))) {
5430 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_APPEND_LOG_TO_TMP_INDEX, log_name);
5431 ✗ goto err;
5432 }
5433
5434
2/4
✓ Branch 0 taken 84423 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 84423 times.
 84423 if (close_crash_safe_index_file()) {
5435 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_CLOSE_TMP_INDEX,
5436 "MYSQL_BIN_LOG::add_log_to_index");
5437 ✗ goto err;
5438 }
5439
5440
3/4
✓ Branch 0 taken 84417 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 84411 times.
 84423 if (move_crash_safe_index_file_to_index_file(need_lock_index)) {
5441
8/16
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6 times.
✗ Branch 15 not taken.
 6 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_MOVE_TMP_TO_INDEX,
5442 "MYSQL_BIN_LOG::add_log_to_index");
5443 6 goto err;
5444 }
5445
5446 84411 return 0;
5447
5448 7 err:
5449 7 return -1;
5450 84418 }
5451
5452 1691851 int MYSQL_BIN_LOG::get_current_log(LOG_INFO *linfo,
5453 bool need_lock_log /*true*/) {
5454
2/2
✓ Branch 0 taken 105695 times.
✓ Branch 1 taken 1586156 times.
 1691851 if (need_lock_log) mysql_mutex_lock(&LOCK_log);
5455 1691851 int ret = raw_get_current_log(linfo);
5456
2/2
✓ Branch 0 taken 105695 times.
✓ Branch 1 taken 1586156 times.
 1691851 if (need_lock_log) mysql_mutex_unlock(&LOCK_log);
5457 1691851 return ret;
5458 }
5459
5460 1692343 int MYSQL_BIN_LOG::raw_get_current_log(LOG_INFO *linfo) {
5461 1692343 strmake(linfo->log_file_name, log_file_name,
5462 sizeof(linfo->log_file_name) - 1);
5463 1692343 linfo->pos = m_binlog_file->position();
5464 1692343 linfo->encrypted_header_size = m_binlog_file->get_encrypted_header_size();
5465 1692343 return 0;
5466 }
5467
5468 8637 static bool check_write_error_code(uint error_code) {
5469
2/2
✓ Branch 0 taken 8506 times.
✓ Branch 1 taken 15 times.
 8521 return error_code == ER_TRANS_CACHE_FULL ||
5470
5/6
✓ Branch 0 taken 8521 times.
✓ Branch 1 taken 116 times.
✓ Branch 2 taken 8430 times.
✓ Branch 3 taken 76 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 8430 times.
 17158 error_code == ER_STMT_CACHE_FULL || error_code == ER_ERROR_ON_WRITE ||
5471 8637 error_code == ER_BINLOG_LOGGING_IMPOSSIBLE;
5472 }
5473
5474 8904 bool MYSQL_BIN_LOG::check_write_error(const THD *thd) {
5475
1/2
✓ Branch 0 taken 8905 times.
✗ Branch 1 not taken.
 8904 DBUG_TRACE;
5476
5477
3/4
✓ Branch 0 taken 8904 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3700 times.
✓ Branch 3 taken 5204 times.
 8905 if (!thd->is_error()) return false;
5478
5479 5204 bool checked = check_write_error_code(thd->get_stmt_da()->mysql_errno());
5480
5481
2/2
✓ Branch 0 taken 4997 times.
✓ Branch 1 taken 207 times.
 5204 if (!checked) {
5482 /* Check all conditions for one that matches the expected error */
5483 const Sql_condition *err;
5484 Diagnostics_area::Sql_condition_iterator it =
5485
1/2
✓ Branch 0 taken 4997 times.
✗ Branch 1 not taken.
 4997 thd->get_stmt_da()->sql_conditions();
5486
6/8
✓ Branch 0 taken 8430 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3433 times.
✓ Branch 3 taken 4997 times.
✓ Branch 4 taken 3433 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3433 times.
✓ Branch 7 taken 4997 times.
 8430 while ((err = it++) != nullptr && !checked) {
5487 3433 checked = check_write_error_code(err->mysql_errno());
5488 }
5489 }
5490
3/10
✓ Branch 0 taken 5204 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5205 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 5205 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 5204 DBUG_PRINT("return", ("checked: %s", YESNO(checked)));
5491 5205 return checked;
5492 8905 }
5493
5494 97 void MYSQL_BIN_LOG::report_cache_write_error(THD *thd, bool is_transactional) {
5495
1/2
✓ Branch 0 taken 97 times.
✗ Branch 1 not taken.
 97 DBUG_TRACE;
5496
5497 97 write_error = true;
5498
5499
2/4
✓ Branch 0 taken 97 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 97 times.
 97 if (check_write_error(thd)) return;
5500
5501
3/4
✓ Branch 0 taken 97 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✓ Branch 3 taken 37 times.
 97 if (my_errno() == EFBIG) {
5502
2/2
✓ Branch 0 taken 53 times.
✓ Branch 1 taken 7 times.
 60 if (is_transactional) {
5503
1/2
✓ Branch 0 taken 53 times.
✗ Branch 1 not taken.
 53 my_error(ER_TRANS_CACHE_FULL, MYF(MY_WME));
5504 } else {
5505
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 my_error(ER_STMT_CACHE_FULL, MYF(MY_WME));
5506 }
5507 } else {
5508 char errbuf[MYSYS_STRERROR_SIZE];
5509
1/2
✓ Branch 0 taken 37 times.
✗ Branch 1 not taken.
 37 my_error(ER_ERROR_ON_WRITE, MYF(MY_WME), name, errno,
5510
1/2
✓ Branch 0 taken 37 times.
✗ Branch 1 not taken.
 37 my_strerror(errbuf, sizeof(errbuf), errno));
5511 }
5512
1/2
✓ Branch 0 taken 97 times.
✗ Branch 1 not taken.
 97 }
5513
5514 10499818 static int compare_log_name(const char *log_1, const char *log_2) {
5515 10499818 const char *log_1_basename = log_1 + dirname_length(log_1);
5516 10499809 const char *log_2_basename = log_2 + dirname_length(log_2);
5517
5518 10499817 return strcmp(log_1_basename, log_2_basename);
5519 }
5520
5521 /**
5522 Find the position in the log-index-file for the given log name.
5523
5524 @param[out] linfo The found log file name will be stored here, along
5525 with the byte offset of the next log file name in the index file.
5526 @param log_name Filename to find in the index file, or NULL if we
5527 want to read the first entry.
5528 @param need_lock_index If false, this function acquires LOCK_index;
5529 otherwise the lock should already be held by the caller.
5530
5531 @note
5532 On systems without the truncate function the file will end with one or
5533 more empty lines. These will be ignored when reading the file.
5534
5535 @retval
5536 0 ok
5537 @retval
5538 LOG_INFO_EOF End of log-index-file found
5539 @retval
5540 LOG_INFO_IO Got IO error while reading file
5541 */
5542
5543 255109 int MYSQL_BIN_LOG::find_log_pos(LOG_INFO *linfo, const char *log_name,
5544 bool need_lock_index) {
5545 255109 int error = 0;
5546 255109 char *full_fname = linfo->log_file_name;
5547 char full_log_name[FN_REFLEN], fname[FN_REFLEN];
5548
1/2
✓ Branch 0 taken 255109 times.
✗ Branch 1 not taken.
 255109 DBUG_TRACE;
5549 255109 full_log_name[0] = full_fname[0] = 0;
5550
5551 /*
5552 Mutex needed because we need to make sure the file pointer does not
5553 move from under our feet
5554 */
5555
2/2
✓ Branch 0 taken 89390 times.
✓ Branch 1 taken 165719 times.
 255109 if (need_lock_index)
5556
1/2
✓ Branch 0 taken 89390 times.
✗ Branch 1 not taken.
 89390 mysql_mutex_lock(&LOCK_index);
5557 else
5558 165719 mysql_mutex_assert_owner(&LOCK_index);
5559
5560
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 255106 times.
 255109 if (!my_b_inited(&index_file)) {
5561 3 error = LOG_INFO_IO;
5562 3 goto end;
5563 }
5564
5565 // extend relative paths for log_name to be searched
5566
2/2
✓ Branch 0 taken 95249 times.
✓ Branch 1 taken 159857 times.
 255106 if (log_name) {
5567
2/4
✓ Branch 0 taken 95249 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 95249 times.
 95249 if (normalize_binlog_name(full_log_name, log_name, is_relay_log)) {
5568 ✗ error = LOG_INFO_EOF;
5569 ✗ goto end;
5570 }
5571 }
5572
5573
3/10
✓ Branch 0 taken 255106 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 255106 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 255106 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 255106 DBUG_PRINT("enter", ("log_name: %s, full_log_name: %s",
5574 log_name ? log_name : "NULL", full_log_name));
5575
5576 /* As the file is flushed, we can't get an error here */
5577
1/2
✓ Branch 0 taken 255106 times.
✗ Branch 1 not taken.
 255106 my_b_seek(&index_file, (my_off_t)0);
5578
5579 for (;;) {
5580 size_t length;
5581 2430186 my_off_t offset = my_b_tell(&index_file);
5582
5583
3/4
✓ Branch 0 taken 2430186 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 2430172 times.
 2430186 DBUG_EXECUTE_IF("simulate_find_log_pos_error", error = LOG_INFO_EOF;
5584 break;);
5585 /* If we get 0 or 1 characters, this is the end of the file */
5586
3/4
✓ Branch 0 taken 2430186 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20402 times.
✓ Branch 3 taken 2409784 times.
 2430186 if ((length = my_b_gets(&index_file, fname, FN_REFLEN)) <= 1) {
5587 /* Did not find the given entry; Return not found or error */
5588
1/2
✓ Branch 0 taken 20402 times.
✗ Branch 1 not taken.
 20402 error = !index_file.error ? LOG_INFO_EOF : LOG_INFO_IO;
5589 20402 break;
5590 }
5591
5592 // extend relative paths and match against full path
5593
2/4
✓ Branch 0 taken 2409784 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2409784 times.
 2409784 if (normalize_binlog_name(full_fname, fname, is_relay_log)) {
5594 ✗ error = LOG_INFO_EOF;
5595 ✗ break;
5596 }
5597 // if the log entry matches, null string matching anything
5598
7/8
✓ Branch 0 taken 2255047 times.
✓ Branch 1 taken 154737 times.
✓ Branch 2 taken 2255047 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 79967 times.
✓ Branch 5 taken 2175080 times.
✓ Branch 6 taken 234704 times.
✓ Branch 7 taken 2175080 times.
 2409784 if (!log_name || !compare_log_name(full_fname, full_log_name)) {
5599
3/8
✓ Branch 0 taken 234704 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 234704 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 234704 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 234704 DBUG_PRINT("info", ("Found log file entry"));
5600 234704 linfo->index_file_start_offset = offset;
5601 234704 linfo->index_file_offset = my_b_tell(&index_file);
5602 234704 break;
5603 }
5604 2175080 linfo->entry_index++;
5605 2175080 }
5606
5607 255109 end:
5608
3/4
✓ Branch 0 taken 89390 times.
✓ Branch 1 taken 165719 times.
✓ Branch 2 taken 89390 times.
✗ Branch 3 not taken.
 255109 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
5609 255109 return error;
5610 255109 }
5611
5612 /**
5613 Find the position in the log-index-file for the given log name.
5614
5615 @param[out] linfo The filename will be stored here, along with the
5616 byte offset of the next filename in the index file.
5617
5618 @param need_lock_index If true, LOCK_index will be acquired;
5619 otherwise it should already be held by the caller.
5620
5621 @note
5622 - Before calling this function, one has to call find_log_pos()
5623 to set up 'linfo'
5624 - Mutex needed because we need to make sure the file pointer does not move
5625 from under our feet
5626
5627 @retval 0 ok
5628 @retval LOG_INFO_EOF End of log-index-file found
5629 @retval LOG_INFO_IO Got IO error while reading file
5630 */
5631 547489 int MYSQL_BIN_LOG::find_next_log(LOG_INFO *linfo, bool need_lock_index) {
5632 547489 int error = 0;
5633 size_t length;
5634 char fname[FN_REFLEN];
5635 547489 char *full_fname = linfo->log_file_name;
5636
5637
2/2
✓ Branch 0 taken 248441 times.
✓ Branch 1 taken 299048 times.
 547489 if (need_lock_index)
5638
1/2
✓ Branch 0 taken 248441 times.
✗ Branch 1 not taken.
 248441 mysql_mutex_lock(&LOCK_index);
5639 else
5640 299048 mysql_mutex_assert_owner(&LOCK_index);
5641
5642
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 547489 times.
 547489 if (!my_b_inited(&index_file)) {
5643 ✗ error = LOG_INFO_IO;
5644 ✗ goto err;
5645 }
5646 /* As the file is flushed, we can't get an error here */
5647
1/2
✓ Branch 0 taken 547489 times.
✗ Branch 1 not taken.
 547489 my_b_seek(&index_file, linfo->index_file_offset);
5648
5649 547489 linfo->index_file_start_offset = linfo->index_file_offset;
5650
3/4
✓ Branch 0 taken 547489 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 82759 times.
✓ Branch 3 taken 464730 times.
 547489 if ((length = my_b_gets(&index_file, fname, FN_REFLEN)) <= 1) {
5651
1/2
✓ Branch 0 taken 82759 times.
✗ Branch 1 not taken.
 82759 error = !index_file.error ? LOG_INFO_EOF : LOG_INFO_IO;
5652 82759 goto err;
5653 }
5654
5655
1/2
✓ Branch 0 taken 464730 times.
✗ Branch 1 not taken.
 464730 if (fname[0] != 0) {
5656
2/4
✓ Branch 0 taken 464730 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 464730 times.
 464730 if (normalize_binlog_name(full_fname, fname, is_relay_log)) {
5657 ✗ error = LOG_INFO_EOF;
5658 ✗ goto err;
5659 }
5660 464730 length = strlen(full_fname);
5661 }
5662
5663 464730 linfo->index_file_offset = my_b_tell(&index_file);
5664
5665 547489 err:
5666
3/4
✓ Branch 0 taken 248441 times.
✓ Branch 1 taken 299048 times.
✓ Branch 2 taken 248441 times.
✗ Branch 3 not taken.
 547489 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
5667 547489 return error;
5668 }
5669
5670 /**
5671 Find the relay log name following the given name from relay log index file.
5672
5673 @param[in,out] log_name The name is full path name.
5674
5675 @return return 0 if it finds next relay log. Otherwise return the error code.
5676 */
5677 ✗ int MYSQL_BIN_LOG::find_next_relay_log(char log_name[FN_REFLEN + 1]) {
5678 ✗ LOG_INFO info;
5679 int error;
5680 char relative_path_name[FN_REFLEN + 1];
5681
5682 ✗ if (fn_format(relative_path_name, log_name + dirname_length(log_name),
5683 ✗ mysql_data_home, "", 0) == NullS)
5684 ✗ return 1;
5685
5686 ✗ mysql_mutex_lock(&LOCK_index);
5687
5688 ✗ error = find_log_pos(&info, relative_path_name, false);
5689 ✗ if (error == 0) {
5690 ✗ error = find_next_log(&info, false);
5691 ✗ if (error == 0) strcpy(log_name, info.log_file_name);
5692 }
5693
5694 ✗ mysql_mutex_unlock(&LOCK_index);
5695 ✗ return error;
5696 }
5697
5698 16920 std::pair<int, std::list<std::string>> MYSQL_BIN_LOG::get_log_index(
5699 bool need_lock_index) {
5700
1/2
✓ Branch 0 taken 16920 times.
✗ Branch 1 not taken.
 16920 DBUG_TRACE;
5701 16920 LOG_INFO log_info;
5702
5703
2/2
✓ Branch 0 taken 4213 times.
✓ Branch 1 taken 12707 times.
 16920 if (need_lock_index)
5704
1/2
✓ Branch 0 taken 4213 times.
✗ Branch 1 not taken.
 4213 mysql_mutex_lock(&LOCK_index);
5705 else
5706 12707 mysql_mutex_assert_owner(&LOCK_index);
5707
5708 16920 std::list<std::string> filename_list;
5709 16920 int error = 0;
5710 16920 for (error =
5711
1/2
✓ Branch 0 taken 16920 times.
✗ Branch 1 not taken.
 16920 this->find_log_pos(&log_info, nullptr, false /*need_lock_index*/);
5712
2/2
✓ Branch 0 taken 229023 times.
✓ Branch 1 taken 16920 times.
 245943 error == 0;
5713 229023 error = this->find_next_log(&log_info, false /*need_lock_index*/)) {
5714
3/6
✓ Branch 0 taken 229023 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 229023 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 229023 times.
✗ Branch 5 not taken.
 229023 filename_list.push_back(std::string(log_info.log_file_name));
5715 }
5716
5717
3/4
✓ Branch 0 taken 4213 times.
✓ Branch 1 taken 12707 times.
✓ Branch 2 taken 4213 times.
✗ Branch 3 not taken.
 16920 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
5718
5719
1/2
✓ Branch 0 taken 16920 times.
✗ Branch 1 not taken.
 33840 return std::make_pair(error, filename_list);
5720 16920 }
5721
5722 /**
5723 Removes files, as part of a RESET MASTER or RESET SLAVE statement,
5724 by deleting all logs referred to in the index file and the index
5725 file. Then, it creates a new index file and a new log file.
5726
5727 The new index file will only contain the new log file.
5728
5729 @param thd Thread
5730 @param delete_only If true, do not create a new index file and
5731 a new log file.
5732
5733 @note
5734 If not called from slave thread, write start event to new log
5735
5736 @retval
5737 0 ok
5738 @retval
5739 1 error
5740 */
5741 29987 bool MYSQL_BIN_LOG::reset_logs(THD *thd, bool delete_only) {
5742 29987 LOG_INFO linfo;
5743 29987 bool error = false;
5744 int err;
5745 29987 const char *save_name = nullptr;
5746 29987 Checkable_rwlock *sid_lock = nullptr;
5747
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 DBUG_TRACE;
5748
5749 /*
5750 Flush logs for storage engines, so that the last transaction
5751 is persisted inside storage engines.
5752 */
5753
2/4
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 29987 times.
 29987 assert(!thd->is_log_reset());
5754
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 thd->set_log_reset();
5755
2/4
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 29987 times.
 29987 if (ha_flush_logs()) {
5756 ✗ thd->clear_log_reset();
5757 ✗ return true;
5758 }
5759
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 thd->clear_log_reset();
5760
5761
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 ha_reset_logs(thd);
5762
5763 /*
5764 We need to get both locks to be sure that no one is trying to
5765 write to the index log file.
5766 */
5767
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 mysql_mutex_lock(&LOCK_log);
5768
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 mysql_mutex_lock(&LOCK_index);
5769
5770
2/2
✓ Branch 0 taken 20220 times.
✓ Branch 1 taken 9767 times.
 29987 if (is_relay_log)
5771 20220 sid_lock = previous_gtid_set_relaylog->get_sid_map()->get_sid_lock();
5772 else
5773 9767 sid_lock = global_sid_lock;
5774
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 sid_lock->wrlock();
5775
5776 /* Save variables so that we can reopen the log */
5777 29987 save_name = name;
5778 29987 name = nullptr; // Protect against free
5779
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 close(LOG_CLOSE_TO_BE_OPENED, false /*need_lock_log=false*/,
5780 false /*need_lock_index=false*/);
5781
5782 /*
5783 First delete all old log files and then update the index file.
5784 As we first delete the log files and do not use sort of logging,
5785 a crash may lead to an inconsistent state where the index has
5786 references to non-existent files.
5787
5788 We need to invert the steps and use the purge_index_file methods
5789 in order to make the operation safe.
5790 */
5791
5792
3/4
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 29978 times.
 29987 if ((err = find_log_pos(&linfo, NullS, false /*need_lock_index=false*/)) !=
5793 0) {
5794 9 uint errcode = purge_log_get_error_code(err);
5795
8/16
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 9 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 9 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 9 times.
✗ Branch 15 not taken.
 9 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_LOCATE_OLD_BINLOG_OR_RELAY_LOG_FILES);
5796
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 my_error(errcode, MYF(0));
5797 9 error = true;
5798 9 goto err;
5799 }
5800
5801 for (;;) {
5802
3/4
✓ Branch 0 taken 46247 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 46237 times.
 46247 if ((error = my_delete_allow_opened(linfo.log_file_name, MYF(0))) != 0) {
5803
3/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 3 times.
 10 if (my_errno() == ENOENT) {
5804 21 push_warning_printf(
5805
2/4
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
 7 current_thd, Sql_condition::SL_WARNING, ER_LOG_PURGE_NO_FILE,
5806
2/4
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
 7 ER_THD(current_thd, ER_LOG_PURGE_NO_FILE), linfo.log_file_name);
5807
8/16
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 7 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 7 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 7 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 7 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 7 times.
✗ Branch 15 not taken.
 7 LogErr(INFORMATION_LEVEL, ER_BINLOG_CANT_DELETE_FILE,
5808 linfo.log_file_name);
5809
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 set_my_errno(0);
5810 7 error = false;
5811 } else {
5812
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 push_warning_printf(current_thd, Sql_condition::SL_WARNING,
5813 ER_BINLOG_PURGE_FATAL_ERR,
5814 "a problem with deleting %s; "
5815 "consider examining correspondence "
5816 "of your binlog index file "
5817 "to the actual binlog files",
5818 linfo.log_file_name);
5819
8/16
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
 3 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_DELETE_FILE, linfo.log_file_name);
5820
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 my_error(ER_BINLOG_PURGE_FATAL_ERR, MYF(0));
5821 3 error = true;
5822 3 goto err;
5823 }
5824 }
5825
3/4
✓ Branch 0 taken 46244 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29975 times.
✓ Branch 3 taken 16269 times.
 46244 if (find_next_log(&linfo, false /*need_lock_index=false*/)) break;
5826 }
5827
5828 /* Start logging with a new file */
5829
1/2
✓ Branch 0 taken 29975 times.
✗ Branch 1 not taken.
 29975 close(LOG_CLOSE_INDEX | LOG_CLOSE_TO_BE_OPENED, false /*need_lock_log=false*/,
5830 false /*need_lock_index=false*/);
5831
3/4
✓ Branch 0 taken 29975 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 29972 times.
 29975 if ((error = my_delete_allow_opened(index_file_name,
5832 MYF(0)))) // Reset (open will update)
5833 {
5834
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 3 if (my_errno() == ENOENT) {
5835 ✗ push_warning_printf(
5836 ✗ current_thd, Sql_condition::SL_WARNING, ER_LOG_PURGE_NO_FILE,
5837 ✗ ER_THD(current_thd, ER_LOG_PURGE_NO_FILE), index_file_name);
5838 ✗ LogErr(INFORMATION_LEVEL, ER_BINLOG_CANT_DELETE_FILE, index_file_name);
5839 ✗ set_my_errno(0);
5840 ✗ error = false;
5841 } else {
5842
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 push_warning_printf(current_thd, Sql_condition::SL_WARNING,
5843 ER_BINLOG_PURGE_FATAL_ERR,
5844 "a problem with deleting %s; "
5845 "consider examining correspondence "
5846 "of your binlog index file "
5847 "to the actual binlog files",
5848
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 index_file_name);
5849
8/16
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
 3 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_DELETE_FILE, index_file_name);
5850
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 my_error(ER_BINLOG_PURGE_FATAL_ERR, MYF(0));
5851 3 error = true;
5852 3 goto err;
5853 }
5854 }
5855
5/8
✓ Branch 0 taken 29972 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 29969 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3 times.
 29972 DBUG_EXECUTE_IF("wait_for_kill_gtid_state_clear", {
5856 const char action[] = "now WAIT_FOR kill_gtid_state_clear";
5857 assert(!debug_sync_set_action(thd, STRING_WITH_LEN(action)));
5858 };);
5859
5860 /*
5861 For relay logs we clear the gtid state associated per channel(i.e rli)
5862 in the purge_relay_logs()
5863 */
5864
2/2
✓ Branch 0 taken 9758 times.
✓ Branch 1 taken 20214 times.
 29972 if (!is_relay_log) {
5865
3/4
✓ Branch 0 taken 9758 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 9752 times.
 9758 if (gtid_state->clear(thd)) {
5866 6 error = true;
5867 }
5868 /*
5869 Don't clear global_sid_map because gtid_state->clear() above didn't
5870 touched owned_gtids GTID set.
5871 */
5872
4/6
✓ Branch 0 taken 9752 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 9752 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9752 times.
 9758 error = error || gtid_state->init();
5873 }
5874
5875
2/2
✓ Branch 0 taken 27126 times.
✓ Branch 1 taken 2846 times.
 29972 if (!delete_only) {
5876
2/4
✓ Branch 0 taken 27126 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27126 times.
✗ Branch 3 not taken.
 27126 if (!open_index_file(index_file_name, nullptr,
5877 false /*need_lock_index=false*/))
5878 27126 error = open_binlog(save_name, nullptr, max_size, false,
5879 false /*need_lock_index=false*/,
5880 false /*need_sid_lock=false*/, nullptr,
5881
5/6
✓ Branch 0 taken 27126 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27125 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 27119 times.
 27126 thd->lex->next_binlog_file_nr) ||
5882 error;
5883 }
5884 /* String has been duplicated, free old file-name */
5885
2/2
✓ Branch 0 taken 2847 times.
✓ Branch 1 taken 27125 times.
 29972 if (name != nullptr) {
5886
1/2
✓ Branch 0 taken 27125 times.
✗ Branch 1 not taken.
 27125 my_free(const_cast<char *>(save_name));
5887 27125 save_name = nullptr;
5888 }
5889
5890 2847 err:
5891
2/2
✓ Branch 0 taken 2862 times.
✓ Branch 1 taken 27125 times.
 29987 if (name == nullptr)
5892 2862 name = const_cast<char *>(save_name); // restore old file-name
5893
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 sid_lock->unlock();
5894
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 count_binlog_space(false);
5895
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 mysql_mutex_unlock(&LOCK_index);
5896
1/2
✓ Branch 0 taken 29987 times.
✗ Branch 1 not taken.
 29987 mysql_mutex_unlock(&LOCK_log);
5897 29987 return error;
5898 29987 }
5899
5900 /**
5901 Set the name of crash safe index file.
5902
5903 @retval
5904 0 ok
5905 @retval
5906 1 error
5907 */
5908 84650 int MYSQL_BIN_LOG::set_crash_safe_index_file_name(const char *base_file_name) {
5909 84650 int error = 0;
5910
1/2
✓ Branch 0 taken 84650 times.
✗ Branch 1 not taken.
 84650 DBUG_TRACE;
5911
1/2
✓ Branch 0 taken 84650 times.
✗ Branch 1 not taken.
 84650 if (fn_format(crash_safe_index_file_name, base_file_name, mysql_data_home,
5912 ".index_crash_safe",
5913
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84650 times.
 84650 MYF(MY_UNPACK_FILENAME | MY_SAFE_PATH | MY_REPLACE_EXT)) ==
5914 nullptr) {
5915 ✗ error = 1;
5916 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_SET_TMP_INDEX_NAME);
5917 }
5918 84650 return error;
5919 84650 }
5920
5921 /**
5922 Open a (new) crash safe index file.
5923
5924 @note
5925 The crash safe index file is a special file
5926 used for guaranteeing index file crash safe.
5927 @retval
5928 0 ok
5929 @retval
5930 1 error
5931 */
5932 108997 int MYSQL_BIN_LOG::open_crash_safe_index_file() {
5933 108997 int error = 0;
5934 108997 File file = -1;
5935
5936
1/2
✓ Branch 0 taken 108997 times.
✗ Branch 1 not taken.
 108997 DBUG_TRACE;
5937
5938
1/2
✓ Branch 0 taken 108997 times.
✗ Branch 1 not taken.
 108997 if (!my_b_inited(&crash_safe_index_file)) {
5939 108997 myf flags = MY_WME | MY_NABP | MY_WAIT_IF_FULL;
5940
2/2
✓ Branch 0 taken 78120 times.
✓ Branch 1 taken 30877 times.
 108997 if (is_relay_log) flags = flags | MY_REPORT_WAITING_IF_FULL;
5941
5942
1/2
✓ Branch 0 taken 108997 times.
✗ Branch 1 not taken.
 108997 if ((file = my_open(crash_safe_index_file_name, O_RDWR | O_CREAT,
5943
2/4
✓ Branch 0 taken 108997 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 108997 times.
 217994 MYF(MY_WME))) < 0 ||
5944
2/4
✓ Branch 0 taken 108997 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 108997 times.
 108997 init_io_cache(&crash_safe_index_file, file, IO_SIZE, WRITE_CACHE, 0,
5945 false, flags)) {
5946 ✗ error = 1;
5947 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_OPEN_TEMPORARY_INDEX_FILE);
5948 }
5949 }
5950 108997 return error;
5951 108997 }
5952
5953 /**
5954 Close the crash safe index file.
5955
5956 @note
5957 The crash safe file is just closed, is not deleted.
5958 Because it is moved to index file later on.
5959 @retval
5960 0 ok
5961 @retval
5962 1 error
5963 */
5964 108996 int MYSQL_BIN_LOG::close_crash_safe_index_file() {
5965 108996 int error = 0;
5966
5967
1/2
✓ Branch 0 taken 108996 times.
✗ Branch 1 not taken.
 108996 DBUG_TRACE;
5968
5969
1/2
✓ Branch 0 taken 108996 times.
✗ Branch 1 not taken.
 108996 if (my_b_inited(&crash_safe_index_file)) {
5970
1/2
✓ Branch 0 taken 108996 times.
✗ Branch 1 not taken.
 108996 end_io_cache(&crash_safe_index_file);
5971
1/2
✓ Branch 0 taken 108996 times.
✗ Branch 1 not taken.
 108996 error = my_close(crash_safe_index_file.file, MYF(0));
5972 }
5973 108996 crash_safe_index_file = IO_CACHE();
5974
5975 108996 return error;
5976 108996 }
5977
5978 /**
5979 Remove logs from index file.
5980
5981 - To make it crash safe, we copy the content of the index file
5982 from index_file_start_offset recorded in log_info to a
5983 crash safe index file first and then move the crash
5984 safe index file to the index file.
5985
5986 @param log_info Store here the found log file name and
5987 position to the NEXT log file name in
5988 the index file.
5989
5990 @param need_update_threads If we want to update the log coordinates
5991 of all threads. False for relay logs,
5992 true otherwise.
5993
5994 @retval
5995 0 ok
5996 @retval
5997 LOG_INFO_IO Got IO error while reading/writing file
5998 */
5999 24573 int MYSQL_BIN_LOG::remove_logs_from_index(LOG_INFO *log_info,
6000 bool need_update_threads) {
6001
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24573 times.
 24573 if (open_crash_safe_index_file()) {
6002 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_TMP_INDEX,
6003 "MYSQL_BIN_LOG::remove_logs_from_index");
6004 ✗ goto err;
6005 }
6006
6007
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24573 times.
 24573 if (copy_file(&index_file, &crash_safe_index_file,
6008 log_info->index_file_start_offset)) {
6009 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_COPY_INDEX_TO_TMP,
6010 "MYSQL_BIN_LOG::remove_logs_from_index");
6011 ✗ goto err;
6012 }
6013
6014
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24573 times.
 24573 if (close_crash_safe_index_file()) {
6015 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_CLOSE_TMP_INDEX,
6016 "MYSQL_BIN_LOG::remove_logs_from_index");
6017 ✗ goto err;
6018 }
6019
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 24570 times.
 24573 DBUG_EXECUTE_IF("fault_injection_copy_part_file", DBUG_SUICIDE(););
6020
6021
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 24561 times.
 24570 if (move_crash_safe_index_file_to_index_file(
6022 false /*need_lock_index=false*/)) {
6023
7/14
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
 3 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_MOVE_TMP_TO_INDEX,
6024 "MYSQL_BIN_LOG::remove_logs_from_index");
6025 3 goto err;
6026 }
6027
6028 // now update offsets in index file for running threads
6029
2/2
✓ Branch 0 taken 210 times.
✓ Branch 1 taken 24351 times.
 24561 if (need_update_threads)
6030 210 adjust_linfo_offsets(log_info->index_file_start_offset);
6031 24561 return 0;
6032
6033 3 err:
6034 3 return LOG_INFO_IO;
6035 }
6036
6037 /**
6038 Remove all logs before the given log from disk and from the index file.
6039
6040 @param to_log Delete all log file name before this file.
6041 @param included If true, to_log is deleted too.
6042 @param need_lock_index Set to true, if the lock_index of the binary log
6043 shall be acquired, false if the called is already the owner of the lock_index.
6044 @param need_update_threads If we want to update the log coordinates of
6045 all threads. False for relay logs, true otherwise.
6046 @param decrease_log_space If not null, decrement this variable of
6047 the amount of log space freed
6048 @param auto_purge True if this is an automatic purge.
6049
6050 @note
6051 If any of the logs before the deleted one is in use,
6052 only purge logs up to this one.
6053
6054 @retval 0 ok
6055 @retval LOG_INFO_EOF to_log not found
6056 @retval LOG_INFO_EMFILE too many files opened
6057 @retval LOG_INFO_FATAL if any other than ENOENT error from
6058 mysql_file_stat() or mysql_file_delete()
6059 */
6060
6061 24578 int MYSQL_BIN_LOG::purge_logs(const char *to_log, bool included,
6062 bool need_lock_index, bool need_update_threads,
6063 ulonglong *decrease_log_space, bool auto_purge) {
6064 24578 int error = 0, no_of_log_files_to_purge = 0, no_of_log_files_purged = 0;
6065 24578 int no_of_threads_locking_log = 0;
6066 24578 bool exit_loop = false;
6067 24578 LOG_INFO log_info;
6068
1/2
✓ Branch 0 taken 24578 times.
✗ Branch 1 not taken.
 24578 THD *thd = current_thd;
6069
1/2
✓ Branch 0 taken 24578 times.
✗ Branch 1 not taken.
 24578 DBUG_TRACE;
6070
3/8
✓ Branch 0 taken 24578 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24578 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 24578 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 24578 DBUG_PRINT("info", ("to_log= %s", to_log));
6071
6072
2/2
✓ Branch 0 taken 138 times.
✓ Branch 1 taken 24440 times.
 24578 if (need_lock_index)
6073
1/2
✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
 138 mysql_mutex_lock(&LOCK_index);
6074 else
6075 24440 mysql_mutex_assert_owner(&LOCK_index);
6076 24578 if ((error =
6077
3/4
✓ Branch 0 taken 24578 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 24576 times.
 24578 find_log_pos(&log_info, to_log, false /*need_lock_index=false*/))) {
6078
8/16
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 2 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 2 times.
✗ Branch 15 not taken.
 2 LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CALLED_WITH_FILE_NOT_IN_INDEX,
6079 to_log);
6080 2 goto err;
6081 }
6082
6083 24576 no_of_log_files_to_purge = log_info.entry_index;
6084
6085
2/4
✓ Branch 0 taken 24576 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24576 times.
 24576 if ((error = open_purge_index_file(true))) {
6086 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CANT_SYNC_INDEX_FILE);
6087 ✗ goto err;
6088 }
6089
6090 /*
6091 File name exists in index file; delete until we find this file
6092 or a file that is used.
6093 */
6094
2/4
✓ Branch 0 taken 24576 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24576 times.
 24576 if ((error = find_log_pos(&log_info, NullS, false /*need_lock_index=false*/)))
6095 ✗ goto err;
6096
6097
5/6
✓ Branch 0 taken 39752 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24576 times.
✓ Branch 3 taken 15176 times.
✓ Branch 4 taken 15266 times.
✓ Branch 5 taken 24486 times.
 64328 while ((compare_log_name(to_log, log_info.log_file_name) ||
6098
2/2
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 24486 times.
 24576 (exit_loop = included))) {
6099
2/4
✓ Branch 0 taken 15266 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15266 times.
 15266 if (is_active(log_info.log_file_name)) {
6100 ✗ if (!auto_purge)
6101 ✗ push_warning_printf(
6102 thd, Sql_condition::SL_WARNING, ER_WARN_PURGE_LOG_IS_ACTIVE,
6103 ER_THD(thd, ER_WARN_PURGE_LOG_IS_ACTIVE), log_info.log_file_name);
6104 ✗ break;
6105 }
6106
6107
2/4
✓ Branch 0 taken 15266 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15266 times.
 15266 if ((no_of_threads_locking_log = log_in_use(log_info.log_file_name))) {
6108 ✗ if (!auto_purge)
6109 ✗ push_warning_printf(thd, Sql_condition::SL_WARNING,
6110 ER_WARN_PURGE_LOG_IN_USE,
6111 ER_THD(thd, ER_WARN_PURGE_LOG_IN_USE),
6112 log_info.log_file_name, no_of_threads_locking_log,
6113 no_of_log_files_purged, no_of_log_files_to_purge);
6114 ✗ break;
6115 }
6116 15266 no_of_log_files_purged++;
6117
6118
2/4
✓ Branch 0 taken 15266 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15266 times.
 15266 if ((error = register_purge_index_entry(log_info.log_file_name))) {
6119 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CANT_COPY_TO_REGISTER_FILE,
6120 log_info.log_file_name);
6121 ✗ goto err;
6122 }
6123
6124
6/8
✓ Branch 0 taken 15266 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15266 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 90 times.
✓ Branch 5 taken 15176 times.
✓ Branch 6 taken 90 times.
✓ Branch 7 taken 15176 times.
 15266 if (find_next_log(&log_info, false /*need_lock_index=false*/) || exit_loop)
6125 90 break;
6126 }
6127
6128
4/6
✓ Branch 0 taken 24576 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 24573 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 24576 DBUG_EXECUTE_IF("crash_purge_before_update_index", DBUG_SUICIDE(););
6129
6130
2/4
✓ Branch 0 taken 24573 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24573 times.
 24573 if ((error = sync_purge_index_file())) {
6131 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CANT_FLUSH_REGISTER_FILE);
6132 ✗ goto err;
6133 }
6134
6135 /* We know how many files to delete. Update index file. */
6136
3/4
✓ Branch 0 taken 24564 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 24561 times.
 24573 if ((error = remove_logs_from_index(&log_info, need_update_threads))) {
6137
8/16
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
 3 LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CANT_UPDATE_INDEX_FILE);
6138 3 goto err;
6139 }
6140
6141 // Update gtid_state->lost_gtids
6142
2/2
✓ Branch 0 taken 210 times.
✓ Branch 1 taken 24351 times.
 24561 if (!is_relay_log) {
6143
1/2
✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
 210 global_sid_lock->wrlock();
6144
1/2
✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
 210 error = init_gtid_sets(
6145 210 nullptr, const_cast<Gtid_set *>(gtid_state->get_lost_gtids()),
6146 opt_source_verify_checksum, false /*false=don't need lock*/,
6147 nullptr /*trx_parser*/, nullptr /*partial_trx*/);
6148
1/2
✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
 210 global_sid_lock->unlock();
6149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 210 times.
 210 if (error) goto err;
6150 }
6151
6152
4/6
✓ Branch 0 taken 24561 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 24558 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 24561 DBUG_EXECUTE_IF("crash_purge_critical_after_update_index", DBUG_SUICIDE(););
6153
6154 24558 err:
6155
6156 24563 int error_index = 0, close_error_index = 0;
6157 /* Read each entry from purge_index_file and delete the file. */
6158
6/8
✓ Branch 0 taken 24558 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 24558 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24558 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 24560 times.
 49121 if (!error && is_inited_purge_index_file() &&
6159
3/4
✓ Branch 0 taken 24558 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 24555 times.
 24558 (error_index = purge_index_entry(thd, decrease_log_space,
6160 false /*need_lock_index=false*/)))
6161
8/16
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
 3 LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_FAILED_TO_PURGE_LOG);
6162
6163
1/2
✓ Branch 0 taken 24563 times.
✗ Branch 1 not taken.
 24563 close_error_index = close_purge_index_file();
6164
6165
4/6
✓ Branch 0 taken 24563 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 24560 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 24563 DBUG_EXECUTE_IF("crash_purge_non_critical_after_update_index",
6166 DBUG_SUICIDE(););
6167
6168
1/2
✓ Branch 0 taken 24560 times.
✗ Branch 1 not taken.
 24560 count_binlog_space(false);
6169
3/4
✓ Branch 0 taken 120 times.
✓ Branch 1 taken 24440 times.
✓ Branch 2 taken 120 times.
✗ Branch 3 not taken.
 24560 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
6170
6171 /*
6172 Error codes from purge logs take precedence.
6173 Then error codes from purging the index entry.
6174 Finally, error codes from closing the purge index file.
6175 */
6176
4/4
✓ Branch 0 taken 24555 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 24552 times.
 24560 error = error ? error : (error_index ? error_index : close_error_index);
6177
6178 24560 return error;
6179 24560 }
6180
6181 84646 int MYSQL_BIN_LOG::set_purge_index_file_name(const char *base_file_name) {
6182 84646 int error = 0;
6183
1/2
✓ Branch 0 taken 84647 times.
✗ Branch 1 not taken.
 84646 DBUG_TRACE;
6184 169294 if (fn_format(
6185
1/2
✓ Branch 0 taken 84647 times.
✗ Branch 1 not taken.
 84647 purge_index_file_name, base_file_name, mysql_data_home, ".~rec~",
6186
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84647 times.
 84647 MYF(MY_UNPACK_FILENAME | MY_SAFE_PATH | MY_REPLACE_EXT)) == nullptr) {
6187 ✗ error = 1;
6188 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_SET_PURGE_INDEX_FILE_NAME);
6189 }
6190 84647 return error;
6191 84647 }
6192
6193 193665 int MYSQL_BIN_LOG::open_purge_index_file(bool destroy) {
6194 193665 int error = 0;
6195 193665 File file = -1;
6196
6197
1/2
✓ Branch 0 taken 193665 times.
✗ Branch 1 not taken.
 193665 DBUG_TRACE;
6198
6199
3/4
✓ Branch 0 taken 109018 times.
✓ Branch 1 taken 84647 times.
✓ Branch 2 taken 109018 times.
✗ Branch 3 not taken.
 193665 if (destroy) close_purge_index_file();
6200
6201
1/2
✓ Branch 0 taken 193665 times.
✗ Branch 1 not taken.
 193665 if (!my_b_inited(&purge_index_file)) {
6202 193665 myf flags = MY_WME | MY_NABP | MY_WAIT_IF_FULL;
6203
2/2
✓ Branch 0 taken 131892 times.
✓ Branch 1 taken 61773 times.
 193665 if (is_relay_log) flags = flags | MY_REPORT_WAITING_IF_FULL;
6204
6205
1/2
✓ Branch 0 taken 193665 times.
✗ Branch 1 not taken.
 193665 if ((file = my_open(purge_index_file_name, O_RDWR | O_CREAT, MYF(MY_WME))) <
6206
2/4
✓ Branch 0 taken 193665 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 193665 times.
 387330 0 ||
6207
4/6
✓ Branch 0 taken 109018 times.
✓ Branch 1 taken 84647 times.
✓ Branch 2 taken 193665 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 193665 times.
 193665 init_io_cache(&purge_index_file, file, IO_SIZE,
6208 (destroy ? WRITE_CACHE : READ_CACHE), 0, false, flags)) {
6209 ✗ error = 1;
6210 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_OPEN_REGISTER_FILE);
6211 }
6212 }
6213 193665 return error;
6214 193665 }
6215
6216 302648 int MYSQL_BIN_LOG::close_purge_index_file() {
6217 302648 int error = 0;
6218
6219
1/2
✓ Branch 0 taken 302648 times.
✗ Branch 1 not taken.
 302648 DBUG_TRACE;
6220
6221
2/2
✓ Branch 0 taken 193629 times.
✓ Branch 1 taken 109019 times.
 302648 if (my_b_inited(&purge_index_file)) {
6222
1/2
✓ Branch 0 taken 193629 times.
✗ Branch 1 not taken.
 193629 end_io_cache(&purge_index_file);
6223
1/2
✓ Branch 0 taken 193629 times.
✗ Branch 1 not taken.
 193629 error = my_close(purge_index_file.file, MYF(0));
6224 }
6225
1/2
✓ Branch 0 taken 302648 times.
✗ Branch 1 not taken.
 302648 my_delete(purge_index_file_name, MYF(0));
6226 302648 new (&purge_index_file) IO_CACHE();
6227
6228 302648 return error;
6229 302648 }
6230
6231 24569 bool MYSQL_BIN_LOG::is_inited_purge_index_file() {
6232
1/2
✓ Branch 0 taken 24569 times.
✗ Branch 1 not taken.
 24569 DBUG_TRACE;
6233 49138 return my_b_inited(&purge_index_file);
6234 24569 }
6235
6236 109015 int MYSQL_BIN_LOG::sync_purge_index_file() {
6237 109015 int error = 0;
6238
1/2
✓ Branch 0 taken 109015 times.
✗ Branch 1 not taken.
 109015 DBUG_TRACE;
6239
6240
5/6
✓ Branch 0 taken 109015 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 109014 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 109013 times.
 218028 if ((error = flush_io_cache(&purge_index_file)) ||
6241
2/4
✓ Branch 0 taken 109013 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 109013 times.
 109014 (error = my_sync(purge_index_file.file, MYF(MY_WME))))
6242 1 return error;
6243
6244 109013 return error;
6245 109014 }
6246
6247 99708 int MYSQL_BIN_LOG::register_purge_index_entry(const char *entry) {
6248 99708 int error = 0;
6249
1/2
✓ Branch 0 taken 99708 times.
✗ Branch 1 not taken.
 99708 DBUG_TRACE;
6250
6251
1/2
✓ Branch 0 taken 99708 times.
✗ Branch 1 not taken.
 99708 if ((error = my_b_write(&purge_index_file, (const uchar *)entry,
6252
2/4
✓ Branch 0 taken 99708 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 99708 times.
 199416 strlen(entry))) ||
6253
2/4
✓ Branch 0 taken 99708 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 99708 times.
 99708 (error = my_b_write(&purge_index_file, (const uchar *)"\n", 1)))
6254 ✗ return error;
6255
6256 99708 return error;
6257 99708 }
6258
6259 84442 int MYSQL_BIN_LOG::register_create_index_entry(const char *entry) {
6260
1/2
✓ Branch 0 taken 84442 times.
✗ Branch 1 not taken.
 84442 DBUG_TRACE;
6261
1/2
✓ Branch 0 taken 84442 times.
✗ Branch 1 not taken.
 168884 return register_purge_index_entry(entry);
6262 84442 }
6263
6264 109216 int MYSQL_BIN_LOG::purge_index_entry(THD *thd, ulonglong *decrease_log_space,
6265 bool need_lock_index) {
6266 MY_STAT s;
6267 109216 int error = 0;
6268 109216 LOG_INFO log_info;
6269 109216 LOG_INFO check_log_info;
6270
6271
1/2
✓ Branch 0 taken 109216 times.
✗ Branch 1 not taken.
 109216 DBUG_TRACE;
6272
6273
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 109216 times.
 109216 assert(my_b_inited(&purge_index_file));
6274
6275 109216 if ((error =
6276
2/4
✓ Branch 0 taken 109216 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 109216 times.
 109216 reinit_io_cache(&purge_index_file, READ_CACHE, 0, false, false))) {
6277 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_REINIT_REGISTER_FILE);
6278 ✗ goto err;
6279 }
6280
6281 for (;;) {
6282 size_t length;
6283
6284
1/2
✓ Branch 0 taken 124505 times.
✗ Branch 1 not taken.
 124505 if ((length = my_b_gets(&purge_index_file, log_info.log_file_name,
6285
2/2
✓ Branch 0 taken 109213 times.
✓ Branch 1 taken 15292 times.
 124505 FN_REFLEN)) <= 1) {
6286
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 109213 times.
 109213 if (purge_index_file.error) {
6287 ✗ error = purge_index_file.error;
6288 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_READ_REGISTER_FILE, error);
6289 ✗ goto err;
6290 }
6291
6292 /* Reached EOF */
6293 109213 break;
6294 }
6295
6296 /* Get rid of the trailing '\n' */
6297 15292 log_info.log_file_name[length - 1] = 0;
6298
6299
3/4
✓ Branch 0 taken 15292 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 15277 times.
 15292 if (!mysql_file_stat(m_key_file_log, log_info.log_file_name, &s, MYF(0))) {
6300
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
 15 if (my_errno() == ENOENT) {
6301 /*
6302 It's not fatal if we can't stat a log file that does not exist;
6303 If we could not stat, we won't delete.
6304 */
6305
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 9 times.
 15 if (thd) {
6306
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 6 push_warning_printf(
6307 thd, Sql_condition::SL_WARNING, ER_LOG_PURGE_NO_FILE,
6308 ER_THD(thd, ER_LOG_PURGE_NO_FILE), log_info.log_file_name);
6309 }
6310
8/16
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 15 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 15 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 15 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 15 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 15 times.
✗ Branch 15 not taken.
 15 LogErr(INFORMATION_LEVEL, ER_CANT_STAT_FILE, log_info.log_file_name);
6311
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 set_my_errno(0);
6312 } else {
6313 /*
6314 Other than ENOENT are fatal
6315 */
6316 ✗ if (thd) {
6317 ✗ push_warning_printf(thd, Sql_condition::SL_WARNING,
6318 ER_BINLOG_PURGE_FATAL_ERR,
6319 "a problem with getting info on being purged %s; "
6320 "consider examining correspondence "
6321 "of your binlog index file "
6322 "to the actual binlog files",
6323 log_info.log_file_name);
6324 } else {
6325 ✗ LogErr(INFORMATION_LEVEL,
6326 ER_BINLOG_CANT_DELETE_LOG_FILE_DOES_INDEX_MATCH_FILES,
6327 log_info.log_file_name);
6328 }
6329 ✗ error = LOG_INFO_FATAL;
6330 ✗ goto err;
6331 }
6332 } else {
6333
3/4
✓ Branch 0 taken 15277 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15262 times.
✓ Branch 3 taken 15 times.
 15277 if ((error = find_log_pos(&check_log_info, log_info.log_file_name,
6334 need_lock_index))) {
6335
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15262 times.
 15262 if (error != LOG_INFO_EOF) {
6336 ✗ if (thd) {
6337 ✗ push_warning_printf(thd, Sql_condition::SL_WARNING,
6338 ER_BINLOG_PURGE_FATAL_ERR,
6339 "a problem with deleting %s and "
6340 "reading the binlog index file",
6341 log_info.log_file_name);
6342 } else {
6343 ✗ LogErr(INFORMATION_LEVEL,
6344 ER_BINLOG_CANT_DELETE_FILE_AND_READ_BINLOG_INDEX,
6345 log_info.log_file_name);
6346 }
6347 ✗ goto err;
6348 }
6349
6350 15262 error = 0;
6351
1/2
✓ Branch 0 taken 15262 times.
✗ Branch 1 not taken.
 15262 if (!need_lock_index) {
6352 /*
6353 This is to avoid triggering an error in NDB.
6354
6355 @todo: This is weird, what does NDB errors have to do with
6356 need_lock_index? Explain better or refactor /Sven
6357 */
6358
2/4
✓ Branch 0 taken 15262 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15262 times.
✗ Branch 3 not taken.
 15262 ha_binlog_index_purge_file(current_thd, log_info.log_file_name);
6359 }
6360
6361
3/8
✓ Branch 0 taken 15262 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15262 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15262 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 15262 DBUG_PRINT("info", ("purging %s", log_info.log_file_name));
6362
3/4
✓ Branch 0 taken 15262 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15259 times.
✓ Branch 3 taken 3 times.
 15262 if (!mysql_file_delete(key_file_binlog, log_info.log_file_name,
6363 MYF(0))) {
6364
6/10
✓ Branch 0 taken 15259 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 15258 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 times.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
 15259 DBUG_EXECUTE_IF("wait_in_purge_index_entry", {
6365 const char action[] =
6366 "now SIGNAL in_purge_index_entry WAIT_FOR go_ahead_sql";
6367 assert(!debug_sync_set_action(thd, STRING_WITH_LEN(action)));
6368 DBUG_SET("-d,wait_in_purge_index_entry");
6369 };);
6370
6371
2/2
✓ Branch 0 taken 14922 times.
✓ Branch 1 taken 337 times.
 15259 if (decrease_log_space) *decrease_log_space -= s.st_size;
6372 } else {
6373
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 3 if (my_errno() == ENOENT) {
6374 ✗ if (thd) {
6375 ✗ push_warning_printf(
6376 thd, Sql_condition::SL_WARNING, ER_LOG_PURGE_NO_FILE,
6377 ER_THD(thd, ER_LOG_PURGE_NO_FILE), log_info.log_file_name);
6378 }
6379 ✗ LogErr(INFORMATION_LEVEL, ER_BINLOG_CANT_DELETE_FILE,
6380 log_info.log_file_name);
6381 ✗ set_my_errno(0);
6382 } else {
6383
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (thd) {
6384
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 push_warning_printf(thd, Sql_condition::SL_WARNING,
6385 ER_BINLOG_PURGE_FATAL_ERR,
6386 "a problem with deleting %s; "
6387 "consider examining correspondence "
6388 "of your binlog index file "
6389 "to the actual binlog files",
6390 log_info.log_file_name);
6391 } else {
6392 ✗ LogErr(INFORMATION_LEVEL,
6393 ER_BINLOG_CANT_DELETE_LOG_FILE_DOES_INDEX_MATCH_FILES,
6394 log_info.log_file_name);
6395 }
6396
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 3 if (my_errno() == EMFILE) {
6397 ✗ DBUG_PRINT("info", ("my_errno: %d, set ret = LOG_INFO_EMFILE",
6398 my_errno()));
6399 ✗ error = LOG_INFO_EMFILE;
6400 ✗ goto err;
6401 }
6402 3 error = LOG_INFO_FATAL;
6403 3 goto err;
6404 }
6405 }
6406 }
6407 }
6408 15289 }
6409
6410 109216 err:
6411 109216 return error;
6412 109216 }
6413
6414 /**
6415 Count a total size of binary logs (except the active one) to the variable
6416 binlog_space_total.
6417
6418 @param need_lock_index If true, this function acquires LOCK_index;
6419 otherwise the caller should already have acquired it.
6420
6421 @retval
6422 0 ok
6423 @retval
6424 LOG_INFO_FATAL if any other than ENOENT error from
6425 mysql_file_stat() or mysql_file_delete()
6426 LOG_INFO_EOF End of log-index-file found
6427 LOG_INFO_IO Got IO error while reading log-index-file
6428 */
6429
6430 54611 int MYSQL_BIN_LOG::count_binlog_space(bool need_lock_index) {
6431
1/2
✓ Branch 0 taken 54611 times.
✗ Branch 1 not taken.
 54611 DBUG_ENTER("count_binlog_space");
6432
3/4
✓ Branch 0 taken 44571 times.
✓ Branch 1 taken 10040 times.
✓ Branch 2 taken 44571 times.
✗ Branch 3 not taken.
 54611 if (is_relay_log) DBUG_RETURN(0);
6433
6434
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10040 times.
 10040 if (need_lock_index)
6435 ✗ mysql_mutex_lock(&LOCK_index);
6436 else
6437 10040 mysql_mutex_assert_owner(&LOCK_index);
6438
6439 int error;
6440 10040 LOG_INFO log_info;
6441 10040 binlog_space_total = 0;
6442
3/4
✓ Branch 0 taken 10040 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 10031 times.
 10040 if ((error = find_log_pos(&log_info, NullS, false /*need_lock_index=false*/)))
6443 9 goto done;
6444
6445 MY_STAT stat_area;
6446
3/4
✓ Branch 0 taken 10756 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 725 times.
✓ Branch 3 taken 10031 times.
 10756 while (!(is_active(log_info.log_file_name))) {
6447
2/4
✓ Branch 0 taken 725 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 725 times.
 725 if (!mysql_file_stat(m_key_file_log, log_info.log_file_name, &stat_area,
6448 MYF(0))) {
6449 ✗ if (my_errno() == ENOENT) {
6450 /*
6451 It's not fatal if we can't stat a log file that does not exist.
6452 */
6453 ✗ set_my_errno(0);
6454 } else {
6455 ✗ error = LOG_INFO_FATAL;
6456 ✗ goto done;
6457 }
6458 } else {
6459 725 binlog_space_total += stat_area.st_size;
6460 }
6461
2/4
✓ Branch 0 taken 725 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 725 times.
 725 if (find_next_log(&log_info, false /*need_lock_index=false*/)) break;
6462 }
6463
6464 10031 error = 0;
6465
6466 10040 done:
6467
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 10040 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 10040 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
6468
1/2
✓ Branch 0 taken 10040 times.
✗ Branch 1 not taken.
 10040 DBUG_RETURN(error);
6469 }
6470
6471 /**
6472 Purge old logs so that we have a total size lower than binlog_space_limit.
6473
6474 @param need_lock_index If true, this function acquires LOCK_index;
6475 otherwise the caller should already have acquired it.
6476
6477 @note
6478 If any of the logs before the deleted one is in use,
6479 only purge logs up to this one.
6480
6481 @retval
6482 0 ok
6483 @retval
6484 LOG_INFO_FATAL if any other than ENOENT error from
6485 mysql_file_stat() or mysql_file_delete()
6486 LOG_INFO_EOF End of log-index-file found
6487 LOG_INFO_IO Got IO error while reading log-index-file
6488 */
6489
6490 64 int MYSQL_BIN_LOG::purge_logs_by_size(bool need_lock_index) {
6491
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
 64 DBUG_ENTER("purge_logs_by_size");
6492
6493
2/6
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 64 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 64 if (is_relay_log || !binlog_space_limit) DBUG_RETURN(0);
6494
6495
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
 64 if (need_lock_index)
6496
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
 64 mysql_mutex_lock(&LOCK_index);
6497 else
6498 ✗ mysql_mutex_assert_owner(&LOCK_index);
6499
6500 64 int error = 0;
6501 64 LOG_INFO log_info;
6502 64 const auto binlog_pos = m_binlog_file->position();
6503
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
 64 count_binlog_space(false);
6504
6505
2/2
✓ Branch 0 taken 61 times.
✓ Branch 1 taken 3 times.
 64 if (!binlog_space_total ||
6506
2/2
✓ Branch 0 taken 34 times.
✓ Branch 1 taken 27 times.
 61 binlog_space_total + binlog_pos <= binlog_space_limit)
6507 37 goto done;
6508
6509
2/4
✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 27 times.
 27 if ((error = find_log_pos(&log_info, NullS, false /*need_lock_index=false*/)))
6510 ✗ goto done;
6511
6512 MY_STAT stat_area;
6513 char to_log[FN_REFLEN];
6514 27 to_log[0] = 0;
6515
3/4
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 51 times.
✓ Branch 3 taken 9 times.
 60 while (!is_active(log_info.log_file_name)) {
6516
2/4
✓ Branch 0 taken 51 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 51 times.
 51 if (!mysql_file_stat(m_key_file_log, log_info.log_file_name, &stat_area,
6517 MYF(0))) {
6518 ✗ if (my_errno() == ENOENT) {
6519 /*
6520 It's not fatal if we can't stat a log file that does not exist.
6521 */
6522 ✗ set_my_errno(0);
6523 } else {
6524 /*
6525 Other than ENOENT are fatal
6526 */
6527 ✗ THD *thd = current_thd;
6528 ✗ if (thd) {
6529 ✗ push_warning_printf(thd, Sql_condition::SL_WARNING,
6530 ER_BINLOG_PURGE_FATAL_ERR,
6531 "a problem with getting info on being purged %s; "
6532 "consider examining correspondence "
6533 "of your binlog index file "
6534 "to the actual binlog files",
6535 log_info.log_file_name);
6536 } else {
6537 ✗ LogErr(INFORMATION_LEVEL, ER_CANT_STAT_FILE, log_info.log_file_name);
6538 }
6539 ✗ error = LOG_INFO_FATAL;
6540 ✗ goto done;
6541 }
6542 }
6543 /* check if a total size of binary logs is bigger than binlog_space_limit
6544 if yes check if it is in use, if not in use then add
6545 it in the list of binary log files to be purged.
6546 */
6547
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 18 times.
 51 else if (binlog_space_total + binlog_pos > binlog_space_limit) {
6548
2/4
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33 times.
 33 if ((log_in_use(log_info.log_file_name))) break;
6549
3/8
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 33 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 33 DBUG_PRINT("info", ("purge_logs_by_size binlog_space_total=%llu "
6550 "binlog_pos=%llu sum=%llu\n",
6551 binlog_space_total, binlog_pos,
6552 binlog_space_total + binlog_pos));
6553
1/2
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
 33 if (binlog_space_total >= (ulonglong)stat_area.st_size)
6554 33 binlog_space_total -= stat_area.st_size;
6555 else
6556 ✗ break;
6557
1/2
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
 33 strmake(to_log, log_info.log_file_name,
6558 sizeof(log_info.log_file_name) - 1);
6559 } else
6560 18 break;
6561
2/4
✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33 times.
 33 if (find_next_log(&log_info, false /*need_lock_index=false*/)) break;
6562 }
6563
6564
2/4
✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27 times.
✗ Branch 3 not taken.
 27 error = (to_log[0] ? purge_logs(to_log, true, false /*need_lock_index=false*/,
6565 true /*need_update_threads=true*/, NULL, true)
6566 : 0);
6567
6568 64 done:
6569
2/4
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 64 times.
✗ Branch 3 not taken.
 64 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
6570
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
 64 DBUG_RETURN(error);
6571 }
6572
6573 /**
6574 Remove all logs before the given file date from disk and from the
6575 index file.
6576
6577 @param purge_time Delete all log files before given date.
6578 @param auto_purge True if this is an automatic purge.
6579
6580 @note
6581 If any of the logs before the deleted one is in use,
6582 only purge logs up to this one.
6583
6584 @retval
6585 0 ok
6586 @retval
6587 LOG_INFO_PURGE_NO_ROTATE Binary file that can't be rotated
6588 LOG_INFO_FATAL if any other than ENOENT error from
6589 mysql_file_stat() or mysql_file_delete()
6590 */
6591
6592 19882 int MYSQL_BIN_LOG::purge_logs_before_date(time_t purge_time, bool auto_purge) {
6593 int error;
6594 19882 int no_of_threads_locking_log = 0, no_of_log_files_purged = 0;
6595 19882 bool log_is_active = false, log_is_in_use = false;
6596 char to_log[FN_REFLEN], copy_log_in_use[FN_REFLEN];
6597 19882 LOG_INFO log_info;
6598 MY_STAT stat_area;
6599
1/2
✓ Branch 0 taken 19882 times.
✗ Branch 1 not taken.
 19882 THD *thd = current_thd;
6600
6601
1/2
✓ Branch 0 taken 19882 times.
✗ Branch 1 not taken.
 19882 DBUG_TRACE;
6602
6603
1/2
✓ Branch 0 taken 19882 times.
✗ Branch 1 not taken.
 19882 mysql_mutex_lock(&LOCK_index);
6604 19882 to_log[0] = 0;
6605
6606
2/4
✓ Branch 0 taken 19882 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19882 times.
 19882 if ((error = find_log_pos(&log_info, NullS, false /*need_lock_index=false*/)))
6607 ✗ goto err;
6608
6609
3/4
✓ Branch 0 taken 20011 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14862 times.
✓ Branch 3 taken 5149 times.
 20011 while (!(log_is_active = is_active(log_info.log_file_name))) {
6610
3/4
✓ Branch 0 taken 14862 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 14859 times.
 14862 if (!mysql_file_stat(m_key_file_log, log_info.log_file_name, &stat_area,
6611 MYF(0))) {
6612
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 if (my_errno() == ENOENT) {
6613 /*
6614 It's not fatal if we can't stat a log file that does not exist.
6615 */
6616
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 set_my_errno(0);
6617 } else {
6618 /*
6619 Other than ENOENT are fatal
6620 */
6621 ✗ if (thd) {
6622 ✗ push_warning_printf(thd, Sql_condition::SL_WARNING,
6623 ER_BINLOG_PURGE_FATAL_ERR,
6624 "a problem with getting info on being purged %s; "
6625 "consider examining correspondence "
6626 "of your binlog index file "
6627 "to the actual binlog files",
6628 log_info.log_file_name);
6629 } else {
6630 ✗ LogErr(INFORMATION_LEVEL, ER_BINLOG_FAILED_TO_DELETE_LOG_FILE,
6631 log_info.log_file_name);
6632 }
6633 ✗ error = LOG_INFO_FATAL;
6634 ✗ goto err;
6635 }
6636 }
6637 /* check if the binary log file is older than the purge_time
6638 if yes check if it is in use, if not in use then add
6639 it in the list of binary log files to be purged.
6640 */
6641
2/2
✓ Branch 0 taken 126 times.
✓ Branch 1 taken 14733 times.
 14859 else if (stat_area.st_mtime < purge_time) {
6642
2/4
✓ Branch 0 taken 126 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 126 times.
 126 if ((no_of_threads_locking_log = log_in_use(log_info.log_file_name))) {
6643 ✗ if (!auto_purge) {
6644 ✗ log_is_in_use = true;
6645 ✗ strcpy(copy_log_in_use, log_info.log_file_name);
6646 }
6647 ✗ break;
6648 }
6649
1/2
✓ Branch 0 taken 126 times.
✗ Branch 1 not taken.
 126 strmake(to_log, log_info.log_file_name,
6650 sizeof(log_info.log_file_name) - 1);
6651 126 no_of_log_files_purged++;
6652 } else
6653 14733 break;
6654
2/4
✓ Branch 0 taken 129 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 129 times.
 129 if (find_next_log(&log_info, false /*need_lock_index=false*/)) break;
6655 }
6656
6657
2/2
✓ Branch 0 taken 5149 times.
✓ Branch 1 taken 14733 times.
 19882 if (log_is_active) {
6658
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 5132 times.
 5149 if (!auto_purge)
6659
2/4
✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✗ Branch 3 not taken.
 17 push_warning_printf(
6660 thd, Sql_condition::SL_WARNING, ER_WARN_PURGE_LOG_IS_ACTIVE,
6661 ER_THD(thd, ER_WARN_PURGE_LOG_IS_ACTIVE), log_info.log_file_name);
6662 }
6663
6664
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19882 times.
 19882 if (log_is_in_use) {
6665 ✗ int no_of_log_files_to_purge = no_of_log_files_purged + 1;
6666 ✗ while (strcmp(log_file_name, log_info.log_file_name)) {
6667 ✗ if (mysql_file_stat(m_key_file_log, log_info.log_file_name, &stat_area,
6668 MYF(0))) {
6669 ✗ if (stat_area.st_mtime < purge_time)
6670 ✗ no_of_log_files_to_purge++;
6671 else
6672 ✗ break;
6673 }
6674 ✗ if (find_next_log(&log_info, false /*need_lock_index=false*/)) {
6675 ✗ no_of_log_files_to_purge++;
6676 ✗ break;
6677 }
6678 }
6679
6680 ✗ push_warning_printf(thd, Sql_condition::SL_WARNING,
6681 ER_WARN_PURGE_LOG_IN_USE,
6682 ER_THD(thd, ER_WARN_PURGE_LOG_IN_USE), copy_log_in_use,
6683 no_of_threads_locking_log, no_of_log_files_purged,
6684 no_of_log_files_to_purge);
6685 }
6686
6687
3/4
✓ Branch 0 taken 62 times.
✓ Branch 1 taken 19820 times.
✓ Branch 2 taken 62 times.
✗ Branch 3 not taken.
 19882 error = (to_log[0] ? purge_logs(to_log, true, false /*need_lock_index=false*/,
6688 true /*need_update_threads=true*/,
6689 (ulonglong *)nullptr, auto_purge)
6690 : 0);
6691
6692 19882 err:
6693
1/2
✓ Branch 0 taken 19882 times.
✗ Branch 1 not taken.
 19882 mysql_mutex_unlock(&LOCK_index);
6694 19882 return error;
6695 19882 }
6696
6697 /**
6698 Create a new log file name.
6699
6700 @param[out] buf Buffer allocated with at least FN_REFLEN bytes where
6701 new name is stored.
6702 @param log_ident Identity of the binary/relay log.
6703
6704 @note
6705 If file name will be longer then FN_REFLEN it will be truncated
6706 */
6707
6708 16766 void MYSQL_BIN_LOG::make_log_name(char *buf, const char *log_ident) {
6709 16766 size_t dir_len = dirname_length(log_file_name);
6710
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16766 times.
 16766 if (dir_len >= FN_REFLEN) dir_len = FN_REFLEN - 1;
6711 16766 my_stpnmov(buf, log_file_name, dir_len);
6712 16766 strmake(buf + dir_len, log_ident, FN_REFLEN - dir_len - 1);
6713 16766 }
6714
6715 /**
6716 Check if we are writing/reading to the given log file.
6717 */
6718
6719 8205025 bool MYSQL_BIN_LOG::is_active(const char *log_file_name_arg) {
6720 8205025 return !compare_log_name(log_file_name, log_file_name_arg);
6721 }
6722
6723 5385682 void MYSQL_BIN_LOG::inc_prep_xids(THD *thd) {
6724
1/2
✓ Branch 0 taken 5385682 times.
✗ Branch 1 not taken.
 5385682 DBUG_TRACE;
6725 #ifndef NDEBUG
6726 5385682 int result = ++m_atomic_prep_xids;
6727
5/8
✓ Branch 0 taken 5385682 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5385682 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 75 times.
✓ Branch 5 taken 5385607 times.
✓ Branch 6 taken 75 times.
✗ Branch 7 not taken.
 5385682 DBUG_PRINT("debug", ("m_atomic_prep_xids: %d", result));
6728 #else
6729 m_atomic_prep_xids++;
6730 #endif
6731 5385682 thd->get_transaction()->m_flags.xid_written = true;
6732 5385682 }
6733
6734 5385542 void MYSQL_BIN_LOG::dec_prep_xids(THD *thd) {
6735
1/2
✓ Branch 0 taken 5385542 times.
✗ Branch 1 not taken.
 5385542 DBUG_TRACE;
6736 5385542 int32 result = --m_atomic_prep_xids;
6737
5/8
✓ Branch 0 taken 5385542 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5385542 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 73 times.
✓ Branch 5 taken 5385469 times.
✓ Branch 6 taken 73 times.
✗ Branch 7 not taken.
 5385542 DBUG_PRINT("debug", ("m_atomic_prep_xids: %d", result));
6738 5385542 thd->get_transaction()->m_flags.xid_written = false;
6739
2/2
✓ Branch 0 taken 5211159 times.
✓ Branch 1 taken 174383 times.
 5385542 if (result == 0) {
6740
1/2
✓ Branch 0 taken 5211159 times.
✗ Branch 1 not taken.
 5211159 mysql_mutex_lock(&LOCK_xids);
6741
1/2
✓ Branch 0 taken 5211159 times.
✗ Branch 1 not taken.
 5211159 mysql_cond_signal(&m_prep_xids_cond);
6742
1/2
✓ Branch 0 taken 5211159 times.
✗ Branch 1 not taken.
 5211159 mysql_mutex_unlock(&LOCK_xids);
6743 }
6744 5385542 }
6745
6746 /*
6747 Wrappers around new_file_impl to avoid using argument
6748 to control locking. The argument 1) less readable 2) breaks
6749 incapsulation 3) allows external access to the class without
6750 a lock (which is not possible with private new_file_without_locking
6751 method).
6752
6753 @retval
6754 nonzero - error
6755
6756 */
6757
6758 ✗ int MYSQL_BIN_LOG::new_file(
6759 Format_description_log_event *extra_description_event) {
6760 ✗ return new_file_impl(true /*need_lock_log=true*/, extra_description_event);
6761 }
6762
6763 /*
6764 @retval
6765 nonzero - error
6766 */
6767 34006 int MYSQL_BIN_LOG::new_file_without_locking(
6768 Format_description_log_event *extra_description_event) {
6769 34006 return new_file_impl(false /*need_lock_log=false*/, extra_description_event);
6770 }
6771
6772 /**
6773 Start writing to a new log file or reopen the old file.
6774
6775 @param need_lock_log If true, this function acquires LOCK_log;
6776 otherwise the caller should already have acquired it.
6777
6778 @param extra_description_event The master's FDE to be written by the I/O
6779 thread while creating a new relay log file. This should be NULL for
6780 binary log files.
6781
6782 @retval 0 success
6783 @retval nonzero - error
6784
6785 @note The new file name is stored last in the index file
6786 */
6787 34006 int MYSQL_BIN_LOG::new_file_impl(
6788 bool need_lock_log, Format_description_log_event *extra_description_event) {
6789 34006 int error = 0;
6790 34006 bool close_on_error = false;
6791 34006 char new_name[FN_REFLEN], *new_name_ptr = nullptr, *old_name, *file_to_open;
6792 34006 const size_t ERR_CLOSE_MSG_LEN = 1024;
6793 char close_on_error_msg[ERR_CLOSE_MSG_LEN];
6794 34006 memset(close_on_error_msg, 0, sizeof close_on_error_msg);
6795
6796
1/2
✓ Branch 0 taken 34006 times.
✗ Branch 1 not taken.
 34006 DBUG_TRACE;
6797
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 33977 times.
 34006 if (!is_open()) {
6798
3/8
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 29 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 29 DBUG_PRINT("info", ("log is closed"));
6799 29 return error;
6800 }
6801
6802
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33977 times.
 33977 if (need_lock_log)
6803 ✗ mysql_mutex_lock(&LOCK_log);
6804 else
6805 33977 mysql_mutex_assert_owner(&LOCK_log);
6806
6/10
✓ Branch 0 taken 33977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 33968 times.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✗ Branch 9 not taken.
 33977 DBUG_EXECUTE_IF("semi_sync_3-way_deadlock",
6807 DEBUG_SYNC(current_thd, "before_rotate_binlog"););
6808
1/2
✓ Branch 0 taken 33977 times.
✗ Branch 1 not taken.
 33977 mysql_mutex_lock(&LOCK_xids);
6809 /*
6810 We need to ensure that the number of prepared XIDs are 0.
6811
6812 If m_atomic_prep_xids is not zero:
6813 - We wait for storage engine commit, hence decrease m_atomic_prep_xids
6814 - We keep the LOCK_log to block new transactions from being
6815 written to the binary log.
6816 */
6817
2/2
✓ Branch 0 taken 1300 times.
✓ Branch 1 taken 33977 times.
 35277 while (get_prep_xids() > 0) {
6818
1/2
✓ Branch 0 taken 1300 times.
✗ Branch 1 not taken.
 1300 mysql_cond_wait(&m_prep_xids_cond, &LOCK_xids);
6819 }
6820
1/2
✓ Branch 0 taken 33977 times.
✗ Branch 1 not taken.
 33977 mysql_mutex_unlock(&LOCK_xids);
6821
6822
1/2
✓ Branch 0 taken 33977 times.
✗ Branch 1 not taken.
 33977 mysql_mutex_lock(&LOCK_index);
6823
6824 33977 mysql_mutex_assert_owner(&LOCK_log);
6825 33977 mysql_mutex_assert_owner(&LOCK_index);
6826
6827
3/6
✓ Branch 0 taken 33977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33977 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 33977 times.
 67954 if (DBUG_EVALUATE_IF("expire_logs_always", 0, 1) &&
6828
2/4
✓ Branch 0 taken 33977 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33977 times.
 33977 (error = ha_flush_logs())) {
6829 ✗ goto end;
6830 }
6831
6832
2/2
✓ Branch 0 taken 9712 times.
✓ Branch 1 taken 24265 times.
 33977 if (!is_relay_log) {
6833 /* Save set of GTIDs of the last binlog into table on binlog rotation */
6834
3/4
✓ Branch 0 taken 9712 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 9709 times.
 9712 if ((error = gtid_state->save_gtids_of_last_binlog_into_table())) {
6835
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (error == ER_RPL_GTID_TABLE_CANNOT_OPEN) {
6836 3 close_on_error =
6837 3 m_binlog_file->get_real_file_size() >=
6838
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 6 static_cast<my_off_t>(max_size) ||
6839
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 3 DBUG_EVALUATE_IF("simulate_max_binlog_size", true, false);
6840
6841
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (!close_on_error) {
6842
8/16
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
 3 LogErr(ERROR_LEVEL, ER_BINLOG_UNABLE_TO_ROTATE_GTID_TABLE_READONLY,
6843 "Current binlog file was flushed to disk and will be kept in "
6844 "use.");
6845 } else {
6846 ✗ snprintf(close_on_error_msg, sizeof close_on_error_msg,
6847 ✗ ER_THD(current_thd, ER_RPL_GTID_TABLE_CANNOT_OPEN), "mysql",
6848 "gtid_executed");
6849
6850 ✗ if (binlog_error_action != ABORT_SERVER)
6851 ✗ LogErr(WARNING_LEVEL,
6852 ER_BINLOG_UNABLE_TO_ROTATE_GTID_TABLE_READONLY,
6853 "Binary logging going to be disabled.");
6854 }
6855
6856
2/6
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 3 DBUG_EXECUTE_IF("gtid_executed_readonly",
6857 { DBUG_SET("-d,gtid_executed_readonly"); });
6858
2/6
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 3 DBUG_EXECUTE_IF("simulate_max_binlog_size",
6859 { DBUG_SET("-d,simulate_max_binlog_size"); });
6860 } else {
6861 ✗ close_on_error = true;
6862 ✗ snprintf(close_on_error_msg, sizeof close_on_error_msg, "%s",
6863 ✗ ER_THD(current_thd, ER_OOM_SAVE_GTIDS));
6864 }
6865 3 goto end;
6866 }
6867 }
6868
6869 /*
6870 If user hasn't specified an extension, generate a new log name
6871 We have to do this here and not in open as we want to store the
6872 new file name in the current binary log file.
6873 */
6874 33974 new_name_ptr = new_name;
6875
3/4
✓ Branch 0 taken 33974 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 33959 times.
 33974 if ((error = generate_new_name(new_name, name))) {
6876 // Use the old name if generation of new name fails.
6877 15 strcpy(new_name, name);
6878 15 close_on_error = true;
6879 45 snprintf(close_on_error_msg, sizeof close_on_error_msg,
6880
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
 15 ER_THD(current_thd, ER_NO_UNIQUE_LOGFILE), name);
6881
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 if (strlen(close_on_error_msg)) {
6882 15 close_on_error_msg[strlen(close_on_error_msg) - 1] = '\0';
6883 }
6884 15 goto end;
6885 }
6886
6887 /*
6888 Make sure that the log_file is initialized before writing
6889 Rotate_log_event into it.
6890 */
6891
2/2
✓ Branch 0 taken 33958 times.
✓ Branch 1 taken 1 times.
 33959 if (m_binlog_file->is_open()) {
6892 /*
6893 We log the whole file name for log file as the user may decide
6894 to change base names at some point.
6895 */
6896
1/2
✓ Branch 0 taken 33958 times.
✗ Branch 1 not taken.
 33958 Rotate_log_event r(new_name + dirname_length(new_name), 0, LOG_EVENT_OFFSET,
6897
3/4
✓ Branch 0 taken 24264 times.
✓ Branch 1 taken 9694 times.
✓ Branch 2 taken 33958 times.
✗ Branch 3 not taken.
 67916 is_relay_log ? Rotate_log_event::RELAY_LOG : 0);
6898
6899
3/4
✓ Branch 0 taken 33958 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 33953 times.
 33958 if (DBUG_EVALUATE_IF("fault_injection_new_file_rotate_event", (error = 1),
6900
4/4
✓ Branch 0 taken 33953 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 33952 times.
 67910 false) ||
6901
2/4
✓ Branch 0 taken 33952 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33952 times.
 33953 (error = write_event_to_binlog(&r))) {
6902 char errbuf[MYSYS_STRERROR_SIZE];
6903
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 5 DBUG_EXECUTE_IF("fault_injection_new_file_rotate_event", errno = 2;);
6904 5 close_on_error = true;
6905 20 snprintf(close_on_error_msg, sizeof close_on_error_msg,
6906
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 5 ER_THD(current_thd, ER_ERROR_ON_WRITE), name, errno,
6907
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 my_strerror(errbuf, sizeof(errbuf), errno));
6908
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 5 my_printf_error(ER_ERROR_ON_WRITE, ER_THD(current_thd, ER_ERROR_ON_WRITE),
6909
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 MYF(ME_FATALERROR), name, errno,
6910
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 my_strerror(errbuf, sizeof(errbuf), errno));
6911 5 goto end;
6912 }
6913
6914
2/4
✓ Branch 0 taken 33952 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33952 times.
 33952 if ((error = m_binlog_file->flush())) {
6915 ✗ close_on_error = true;
6916 ✗ snprintf(close_on_error_msg, sizeof close_on_error_msg, "%s",
6917 "Either disk is full or file system is read only");
6918 ✗ goto end;
6919 }
6920
2/2
✓ Branch 0 taken 33952 times.
✓ Branch 1 taken 5 times.
 33957 }
6921
6922
3/6
✓ Branch 0 taken 33954 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33953 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 33954 times.
✗ Branch 5 not taken.
 33953 DEBUG_SYNC(current_thd, "after_rotate_event_appended");
6923
6924 33953 old_name = name;
6925 33953 name = nullptr; // Don't free name
6926
1/2
✓ Branch 0 taken 33954 times.
✗ Branch 1 not taken.
 33953 close(LOG_CLOSE_TO_BE_OPENED | LOG_CLOSE_INDEX, false /*need_lock_log=false*/,
6927 false /*need_lock_index=false*/);
6928
6929
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 33938 times.
 33954 if (checksum_alg_reset != binary_log::BINLOG_CHECKSUM_ALG_UNDEF) {
6930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 assert(!is_relay_log);
6931
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 assert(binlog_checksum_options != checksum_alg_reset);
6932 16 binlog_checksum_options = checksum_alg_reset;
6933 }
6934 /*
6935 Note that at this point, atomic_log_state != LOG_CLOSED
6936 (important for is_open()).
6937 */
6938
6939
3/6
✓ Branch 0 taken 33954 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33954 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 33954 times.
✗ Branch 5 not taken.
 33954 DEBUG_SYNC(current_thd, "binlog_rotate_between_close_and_open");
6940 /*
6941 new_file() is only used for rotation (in FLUSH LOGS or because size >
6942 max_binlog_size or max_relay_log_size).
6943 If this is a binary log, the Format_description_log_event at the beginning
6944 of the new file should have created=0 (to distinguish with the
6945 Format_description_log_event written at server startup, which should
6946 trigger temp tables deletion on slaves.
6947 */
6948
6949 /* reopen index binlog file, BUG#34582 */
6950 33954 file_to_open = index_file_name;
6951
1/2
✓ Branch 0 taken 33954 times.
✗ Branch 1 not taken.
 33954 error = open_index_file(index_file_name, nullptr,
6952 false /*need_lock_index=false*/);
6953
2/2
✓ Branch 0 taken 33951 times.
✓ Branch 1 taken 3 times.
 33954 if (!error) {
6954 /* reopen the binary log file. */
6955 33951 file_to_open = new_name_ptr;
6956
1/2
✓ Branch 0 taken 33936 times.
✗ Branch 1 not taken.
 33951 error = open_binlog(old_name, new_name_ptr, max_size,
6957 true /*null_created_arg=true*/,
6958 false /*need_lock_index=false*/,
6959 true /*need_sid_lock=true*/, extra_description_event);
6960 }
6961
6962 /* handle reopening errors */
6963
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 33919 times.
 33939 if (error) {
6964 char errbuf[MYSYS_STRERROR_SIZE];
6965
4/8
✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 20 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 20 times.
✗ Branch 7 not taken.
 20 my_printf_error(ER_CANT_OPEN_FILE, ER_THD(current_thd, ER_CANT_OPEN_FILE),
6966 MYF(ME_FATALERROR), file_to_open, error,
6967 my_strerror(errbuf, sizeof(errbuf), error));
6968 20 close_on_error = true;
6969
1/2
✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.
 40 snprintf(close_on_error_msg, sizeof close_on_error_msg,
6970
2/4
✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.
 20 ER_THD(current_thd, ER_CANT_OPEN_FILE), file_to_open, error,
6971 my_strerror(errbuf, sizeof(errbuf), error));
6972 }
6973
1/2
✓ Branch 0 taken 33939 times.
✗ Branch 1 not taken.
 33939 my_free(old_name);
6974
6975 33962 end:
6976
6977
4/4
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 33919 times.
✓ Branch 2 taken 40 times.
✓ Branch 3 taken 3 times.
 33962 if (error && close_on_error /* rotate, flush or reopen failed */) {
6978 /*
6979 Close whatever was left opened.
6980
6981 We are keeping the behavior as it exists today, ie,
6982 we disable logging and move on (see: BUG#51014).
6983
6984 TODO: as part of WL#1790 consider other approaches:
6985 - kill mysql (safety);
6986 - try multiple locations for opening a log file;
6987 - switch server to protected/readonly mode
6988 - ...
6989 */
6990
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
 40 if (binlog_error_action == ABORT_SERVER) {
6991 char abort_msg[ERR_CLOSE_MSG_LEN + 48];
6992 ✗ memset(abort_msg, 0, sizeof abort_msg);
6993 ✗ snprintf(abort_msg, sizeof abort_msg,
6994 "%s, while rotating the binlog. "
6995 "Aborting the server",
6996 close_on_error_msg);
6997 ✗ exec_binlog_error_action_abort(abort_msg);
6998 } else
6999
9/18
✓ Branch 0 taken 40 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 40 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 40 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 40 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 40 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 40 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 40 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 40 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 40 times.
✗ Branch 17 not taken.
 40 LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_FOR_LOGGING,
7000 new_name_ptr != nullptr ? new_name_ptr : "new file", errno);
7001
7002
1/2
✓ Branch 0 taken 40 times.
✗ Branch 1 not taken.
 40 close(LOG_CLOSE_INDEX, false /*need_lock_log=false*/,
7003 false /*need_lock_index=false*/);
7004 }
7005
7006
1/2
✓ Branch 0 taken 33962 times.
✗ Branch 1 not taken.
 33962 mysql_mutex_unlock(&LOCK_index);
7007
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 33962 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 33962 if (need_lock_log) mysql_mutex_unlock(&LOCK_log);
7008
7009
3/6
✓ Branch 0 taken 33962 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33962 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 33962 times.
✗ Branch 5 not taken.
 33962 DEBUG_SYNC(current_thd, "after_disable_binlog");
7010 33962 return error;
7011 33991 }
7012
7013 /**
7014 Called after an event has been written to the relay log by the IO
7015 thread. This flushes and possibly syncs the file (according to the
7016 sync options), rotates the file if it has grown over the limit, and
7017 finally calls signal_update().
7018
7019 @note The caller must hold LOCK_log before invoking this function.
7020
7021 @param mi Master_info for the IO thread.
7022
7023 @retval false success
7024 @retval true error
7025 */
7026 1767052 bool MYSQL_BIN_LOG::after_write_to_relay_log(Master_info *mi) {
7027
1/2
✓ Branch 0 taken 1767052 times.
✗ Branch 1 not taken.
 1767052 DBUG_TRACE;
7028
3/8
✓ Branch 0 taken 1767052 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1767052 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1767052 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 1767052 DBUG_PRINT("info", ("max_size: %lu", max_size));
7029
7030 // Check pre-conditions
7031 1767052 mysql_mutex_assert_owner(&LOCK_log);
7032
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1767052 times.
 1767052 assert(is_relay_log);
7033
7034 /*
7035 We allow the relay log rotation by relay log size
7036 only if the trx parser is not inside a transaction.
7037 */
7038 1767052 bool can_rotate = mi->transaction_parser.is_not_inside_transaction();
7039
7040 #ifndef NDEBUG
7041 1767052 if (m_binlog_file->get_real_file_size() >
7042
6/8
✓ Branch 0 taken 1767052 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1767052 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18624 times.
✓ Branch 5 taken 1748428 times.
✓ Branch 6 taken 18439 times.
✓ Branch 7 taken 1748613 times.
 1785676 DBUG_EVALUATE_IF("rotate_replica_debug_group", 500, max_size) &&
7043
2/2
✓ Branch 0 taken 18439 times.
✓ Branch 1 taken 185 times.
 18624 !can_rotate) {
7044
3/8
✓ Branch 0 taken 18439 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18439 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 18439 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 18439 DBUG_PRINT("info", ("Postponing the rotation by size waiting for "
7045 "the end of the current transaction."));
7046 }
7047 #endif
7048
7049 // Flush and sync
7050
1/2
✓ Branch 0 taken 1767052 times.
✗ Branch 1 not taken.
 1767052 bool error = flush_and_sync(false);
7051
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1767046 times.
 1767052 if (error) {
7052
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
7053
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 6 ER_THD(current_thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
7054 "failed to flush event to relay log file");
7055
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 truncate_relaylog_file(mi, atomic_binlog_end_pos);
7056 } else {
7057
2/2
✓ Branch 0 taken 371360 times.
✓ Branch 1 taken 1395686 times.
 1767046 if (can_rotate) {
7058
1/2
✓ Branch 0 taken 371360 times.
✗ Branch 1 not taken.
 371360 mysql_mutex_lock(&mi->data_lock);
7059 /*
7060 If the last event of the transaction has been flushed, we can add
7061 the GTID (if it is not empty) to the logged set, or else it will
7062 not be available in the Previous GTIDs of the next relay log file
7063 if we are going to rotate the relay log.
7064 */
7065
1/2
✓ Branch 0 taken 371360 times.
✗ Branch 1 not taken.
 371360 const Gtid *last_gtid_queued = mi->get_queueing_trx_gtid();
7066
2/2
✓ Branch 0 taken 58304 times.
✓ Branch 1 taken 313056 times.
 371360 if (!last_gtid_queued->is_empty()) {
7067
1/2
✓ Branch 0 taken 58304 times.
✗ Branch 1 not taken.
 58304 mi->rli->get_sid_lock()->rdlock();
7068
6/10
✓ Branch 0 taken 58304 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 58298 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 6 times.
 58304 DBUG_SIGNAL_WAIT_FOR(current_thd, "updating_received_transaction_set",
7069 "reached_updating_received_transaction_set",
7070 "continue_updating_received_transaction_set");
7071 58304 mi->rli->add_logged_gtid(last_gtid_queued->sidno,
7072
1/2
✓ Branch 0 taken 58304 times.
✗ Branch 1 not taken.
 58304 last_gtid_queued->gno);
7073
1/2
✓ Branch 0 taken 58304 times.
✗ Branch 1 not taken.
 58304 mi->rli->get_sid_lock()->unlock();
7074 }
7075
7076
3/4
✓ Branch 0 taken 371360 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 327375 times.
✓ Branch 3 taken 43985 times.
 371360 if (mi->is_queueing_trx()) {
7077
1/2
✓ Branch 0 taken 327375 times.
✗ Branch 1 not taken.
 327375 mi->finished_queueing();
7078
7079
1/2
✓ Branch 0 taken 327375 times.
✗ Branch 1 not taken.
 327375 Trx_monitoring_info processing;
7080
1/2
✓ Branch 0 taken 327375 times.
✗ Branch 1 not taken.
 327375 Trx_monitoring_info last;
7081
1/2
✓ Branch 0 taken 327375 times.
✗ Branch 1 not taken.
 327375 mi->get_gtid_monitoring_info()->copy_info_to(&processing, &last);
7082
7083 // update the compression information
7084
1/2
✓ Branch 0 taken 327375 times.
✗ Branch 1 not taken.
 327375 binlog::global_context.monitoring_context()
7085
1/2
✓ Branch 0 taken 327375 times.
✗ Branch 1 not taken.
 327375 .transaction_compression()
7086 327375 .update(binlog::monitoring::log_type::RELAY, last.compression_type,
7087 327375 last.gtid, last.end_time, last.compressed_bytes,
7088
1/2
✓ Branch 0 taken 327375 times.
✗ Branch 1 not taken.
 327375 last.uncompressed_bytes,
7089 327375 mi->rli->get_gtid_set()->get_sid_map());
7090 }
7091
1/2
✓ Branch 0 taken 371360 times.
✗ Branch 1 not taken.
 371360 mysql_mutex_unlock(&mi->data_lock);
7092
7093 /*
7094 If relay log is too big, rotate. But only if not in the middle of a
7095 transaction when GTIDs are enabled.
7096
7097 Also rotate if a deferred flush request has been placed.
7098
7099 We now try to mimic the following master binlog behavior: "A transaction
7100 is written in one chunk to the binary log, so it is never split between
7101 several binary logs. Therefore, if you have big transactions, you might
7102 see binary log files larger than max_binlog_size."
7103 */
7104 371360 if (m_binlog_file->get_real_file_size() >
7105
6/8
✓ Branch 0 taken 371360 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 371360 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 371175 times.
✓ Branch 5 taken 185 times.
✓ Branch 6 taken 186 times.
✓ Branch 7 taken 371174 times.
 742535 DBUG_EVALUATE_IF("rotate_replica_debug_group", 500, max_size) ||
7106
3/4
✓ Branch 0 taken 371175 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 371174 times.
 371175 mi->is_rotate_requested()) {
7107
1/2
✓ Branch 0 taken 186 times.
✗ Branch 1 not taken.
 186 error = new_file_without_locking(mi->get_mi_description_event());
7108
1/2
✓ Branch 0 taken 186 times.
✗ Branch 1 not taken.
 186 mi->clear_rotate_requests();
7109 }
7110 }
7111 }
7112
7113
1/2
✓ Branch 0 taken 1767052 times.
✗ Branch 1 not taken.
 1767052 lock_binlog_end_pos();
7114 1767052 mi->rli->ign_master_log_name_end[0] = 0;
7115
1/2
✓ Branch 0 taken 1767052 times.
✗ Branch 1 not taken.
 1767052 update_binlog_end_pos(false /*need_lock*/);
7116
1/2
✓ Branch 0 taken 1767052 times.
✗ Branch 1 not taken.
 1767052 harvest_bytes_written(mi->rli, true /*need_log_space_lock=true*/);
7117
1/2
✓ Branch 0 taken 1767052 times.
✗ Branch 1 not taken.
 1767052 unlock_binlog_end_pos();
7118
7119 1767052 return error;
7120 1767052 }
7121
7122 12076 bool MYSQL_BIN_LOG::write_event(Log_event *ev, Master_info *mi) {
7123
1/2
✓ Branch 0 taken 12076 times.
✗ Branch 1 not taken.
 12076 DBUG_TRACE;
7124
7125
3/4
✓ Branch 0 taken 12076 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 12075 times.
 12076 DBUG_EXECUTE_IF("fail_to_write_ignored_event_to_relay_log", { return true; });
7126 // check preconditions
7127
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12075 times.
 12075 assert(is_relay_log);
7128
7129 12075 mysql_mutex_assert_owner(&LOCK_log);
7130
7131 // write data
7132 12075 bool error = false;
7133
2/4
✓ Branch 0 taken 12075 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12075 times.
✗ Branch 3 not taken.
 12075 if (!binary_event_serialize(ev, m_binlog_file)) {
7134 12075 bytes_written += ev->common_header->data_written;
7135
1/2
✓ Branch 0 taken 12075 times.
✗ Branch 1 not taken.
 12075 error = after_write_to_relay_log(mi);
7136 } else {
7137 ✗ mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
7138 ✗ ER_THD(current_thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
7139 "failed to write event to the relay log file");
7140 ✗ truncate_relaylog_file(mi, atomic_binlog_end_pos);
7141 ✗ error = true;
7142 }
7143
7144 12075 return error;
7145 12076 }
7146
7147 1754977 bool MYSQL_BIN_LOG::write_buffer(uchar *buf, uint len, Master_info *mi) {
7148
1/2
✓ Branch 0 taken 1754977 times.
✗ Branch 1 not taken.
 1754977 DBUG_TRACE;
7149
7150 // check preconditions
7151
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1754977 times.
 1754977 assert(is_relay_log);
7152 1754977 mysql_mutex_assert_owner(&LOCK_log);
7153
7154 // write data
7155 1754977 bool error = false;
7156
2/4
✓ Branch 0 taken 1754977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1754977 times.
✗ Branch 3 not taken.
 1754977 if (m_binlog_file->write(pointer_cast<const uchar *>(buf), len) == 0) {
7157 1754977 bytes_written += len;
7158
1/2
✓ Branch 0 taken 1754977 times.
✗ Branch 1 not taken.
 1754977 error = after_write_to_relay_log(mi);
7159 } else {
7160 ✗ mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
7161 ✗ ER_THD(current_thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
7162 "failed to write event to the relay log file");
7163 ✗ truncate_relaylog_file(mi, atomic_binlog_end_pos);
7164 ✗ error = true;
7165 }
7166
7167 1754977 return error;
7168 1754977 }
7169
7170 12601 bool MYSQL_BIN_LOG::flush() {
7171
3/4
✓ Branch 0 taken 12598 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 12598 times.
 12601 return m_binlog_file->is_open() && m_binlog_file->flush();
7172 }
7173
7174 1775631 bool MYSQL_BIN_LOG::flush_and_sync(const bool force) {
7175 1775631 mysql_mutex_assert_owner(&LOCK_log);
7176
7177
3/4
✓ Branch 0 taken 1775631 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1775625 times.
 1775631 if (m_binlog_file->flush()) return true;
7178
7179
1/2
✓ Branch 0 taken 1775625 times.
✗ Branch 1 not taken.
 1775625 std::pair<bool, bool> result = sync_binlog_file(force);
7180
7181 1775625 return result.first;
7182 }
7183
7184 44049 void MYSQL_BIN_LOG::start_union_events(THD *thd, query_id_t query_id_param) {
7185
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44049 times.
 44049 assert(!thd->binlog_evt_union.do_union);
7186 44049 thd->binlog_evt_union.do_union = true;
7187 44049 thd->binlog_evt_union.unioned_events = false;
7188 44049 thd->binlog_evt_union.unioned_events_trans = false;
7189 44049 thd->binlog_evt_union.first_query_id = query_id_param;
7190 44049 }
7191
7192 44049 void MYSQL_BIN_LOG::stop_union_events(THD *thd) {
7193
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44049 times.
 44049 assert(thd->binlog_evt_union.do_union);
7194 44049 thd->binlog_evt_union.do_union = false;
7195 44049 }
7196
7197 169205 bool MYSQL_BIN_LOG::is_query_in_union(THD *thd, query_id_t query_id_param) {
7198
2/2
✓ Branch 0 taken 122 times.
✓ Branch 1 taken 169083 times.
 169327 return (thd->binlog_evt_union.do_union &&
7199
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 72 times.
 169327 query_id_param >= thd->binlog_evt_union.first_query_id);
7200 }
7201
7202 /*
7203 Updates thd's position-of-next-event variables
7204 after a *real* write a file.
7205 */
7206 5927057 void MYSQL_BIN_LOG::update_thd_next_event_pos(THD *thd) {
7207
1/2
✓ Branch 0 taken 5927057 times.
✗ Branch 1 not taken.
 5927057 if (likely(thd != nullptr)) {
7208 5927057 thd->set_next_event_pos(log_file_name, m_binlog_file->position());
7209 }
7210 5927057 }
7211
7212 /*
7213 Moves the last bunch of rows from the pending Rows event to a cache (either
7214 transactional cache if is_transaction is @c true, or the non-transactional
7215 cache otherwise. Sets a new pending event.
7216
7217 @param thd a pointer to the user thread.
7218 @param evt a pointer to the row event.
7219 @param is_transactional @c true indicates a transactional cache,
7220 otherwise @c false a non-transactional.
7221 */
7222 36467307 int MYSQL_BIN_LOG::flush_and_set_pending_rows_event(THD *thd,
7223 Rows_log_event *event,
7224 bool is_transactional) {
7225
1/2
✓ Branch 0 taken 36467899 times.
✗ Branch 1 not taken.
 36467307 DBUG_TRACE;
7226
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36467823 times.
 36467899 assert(mysql_bin_log.is_open());
7227
5/8
✓ Branch 0 taken 36467615 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 36467683 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 30 times.
✓ Branch 5 taken 36467653 times.
✓ Branch 6 taken 30 times.
✗ Branch 7 not taken.
 36467823 DBUG_PRINT("enter", ("event: %p", event));
7228
7229 36467683 int error = 0;
7230
1/2
✓ Branch 0 taken 36467824 times.
✗ Branch 1 not taken.
 36467683 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd);
7231
7232
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36467824 times.
 36467824 assert(cache_mngr);
7233
7234 binlog_cache_data *cache_data =
7235 36467824 cache_mngr->get_binlog_cache_data(is_transactional);
7236
7237
5/8
✓ Branch 0 taken 36467742 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 36467911 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 30 times.
✓ Branch 5 taken 36467881 times.
✓ Branch 6 taken 30 times.
✗ Branch 7 not taken.
 36467877 DBUG_PRINT("info", ("cache_mngr->pending(): %p", cache_data->pending()));
7238
7239
2/2
✓ Branch 0 taken 26038195 times.
✓ Branch 1 taken 10429598 times.
 36467911 if (Rows_log_event *pending = cache_data->pending()) {
7240 /*
7241 Write pending event to the cache.
7242 */
7243
3/4
✓ Branch 0 taken 26038204 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 26038196 times.
 26038195 if (cache_data->write_event(pending)) {
7244
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 report_cache_write_error(thd, is_transactional);
7245
5/8
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5 times.
✓ Branch 7 taken 3 times.
 16 if (check_write_error(thd) && cache_data &&
7246
3/4
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 3 times.
 8 stmt_cannot_safely_rollback(thd))
7247 5 cache_data->set_incident();
7248
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 delete pending;
7249 8 cache_data->set_pending(nullptr);
7250 8 return 1;
7251 }
7252
7253
2/2
✓ Branch 0 taken 26038070 times.
✓ Branch 1 taken 126 times.
 26038196 delete pending;
7254 }
7255
7256 36467887 cache_data->set_pending(event);
7257
7258 36467482 return error;
7259 36467490 }
7260
7261 /**
7262 Write an event to the binary log cache.
7263 */
7264
7265 824565 bool MYSQL_BIN_LOG::write_event(Log_event *event_info) {
7266 824565 THD *thd = event_info->thd;
7267 824565 bool error = true;
7268
1/2
✓ Branch 0 taken 824817 times.
✗ Branch 1 not taken.
 824565 DBUG_TRACE;
7269
7270
2/2
✓ Branch 0 taken 15329 times.
✓ Branch 1 taken 809488 times.
 824817 if (thd->binlog_evt_union.do_union) {
7271 /*
7272 In Stored function; Remember that function call caused an update.
7273 We will log the function call to the binary log on function exit
7274 */
7275 15329 thd->binlog_evt_union.unioned_events = true;
7276 15329 thd->binlog_evt_union.unioned_events_trans |=
7277 15329 event_info->is_using_trans_cache();
7278 15329 return false;
7279 }
7280
7281 /*
7282 We only end the statement if we are in a top-level statement. If
7283 we are inside a stored function, we do not end the statement since
7284 this will close all tables on the slave. But there can be a special case
7285 where we are inside a stored function/trigger and a SAVEPOINT is being
7286 set in side the stored function/trigger. This SAVEPOINT execution will
7287 force the pending event to be flushed without an STMT_END_F flag. This
7288 will result in a case where following DMLs will be considered as part of
7289 same statement and result in data loss on slave. Hence in this case we
7290 force the end_stmt to be true.
7291 */
7292 bool const end_stmt =
7293
2/2
✓ Branch 0 taken 1913 times.
✓ Branch 1 taken 21 times.
 1934 (thd->in_sub_stmt && thd->lex->sql_command == SQLCOM_SAVEPOINT)
7294
2/2
✓ Branch 0 taken 1934 times.
✓ Branch 1 taken 807554 times.
 1618976 ? true
7295
4/4
✓ Branch 0 taken 15133 times.
✓ Branch 1 taken 794334 times.
✓ Branch 2 taken 12686 times.
✓ Branch 3 taken 2447 times.
 809467 : (thd->locked_tables_mode && thd->lex->requires_prelocking());
7296
2/4
✓ Branch 0 taken 809531 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 809531 times.
 809325 if (thd->binlog_flush_pending_rows_event(end_stmt,
7297 809488 event_info->is_using_trans_cache()))
7298 ✗ return error;
7299
7300 /*
7301 In most cases this is only called if 'is_open()' is true; in fact this is
7302 mostly called if is_open() *was* true a few instructions before, but it
7303 could have changed since.
7304 */
7305
2/2
✓ Branch 0 taken 809433 times.
✓ Branch 1 taken 25 times.
 809531 if (likely(is_open())) {
7306 /*
7307 In the future we need to add to the following if tests like
7308 "do the involved tables match (to be implemented)
7309 binlog_[wild_]{do|ignore}_table?" (WL#1049)"
7310 */
7311
1/2
✓ Branch 0 taken 809300 times.
✗ Branch 1 not taken.
 809433 const char *local_db = event_info->get_db();
7312
5/6
✓ Branch 0 taken 809497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 694611 times.
✓ Branch 3 taken 114886 times.
✓ Branch 4 taken 115159 times.
✓ Branch 5 taken 694293 times.
 1503866 if ((thd && !(thd->variables.option_bits & OPTION_BIN_LOG)) ||
7313
1/2
✓ Branch 0 taken 694542 times.
✗ Branch 1 not taken.
 694414 (thd->lex->sql_command != SQLCOM_ROLLBACK_TO_SAVEPOINT &&
7314
2/2
✓ Branch 0 taken 679404 times.
✓ Branch 1 taken 15138 times.
 694542 thd->lex->sql_command != SQLCOM_SAVEPOINT &&
7315
2/2
✓ Branch 0 taken 679242 times.
✓ Branch 1 taken 162 times.
 679404 (!event_info->is_no_filter_event() &&
7316
3/4
✓ Branch 0 taken 679394 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 273 times.
✓ Branch 3 taken 679121 times.
 679242 !binlog_filter->db_ok(local_db))))
7317 115159 return false;
7318
7319
3/4
✓ Branch 0 taken 174220 times.
✓ Branch 1 taken 520093 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 174233 times.
 694293 assert(event_info->is_using_trans_cache() ||
7320 event_info->is_using_stmt_cache());
7321
7322
2/4
✓ Branch 0 taken 694304 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 694304 times.
 694326 if (binlog_start_trans_and_stmt(thd, event_info)) return error;
7323
7324 694304 bool is_trans_cache = event_info->is_using_trans_cache();
7325
1/2
✓ Branch 0 taken 694367 times.
✗ Branch 1 not taken.
 694306 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd);
7326 binlog_cache_data *cache_data =
7327 694367 cache_mngr->get_binlog_cache_data(is_trans_cache);
7328
7329
5/8
✓ Branch 0 taken 694310 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 694312 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 91 times.
✓ Branch 5 taken 694221 times.
✓ Branch 6 taken 98 times.
✗ Branch 7 not taken.
 694365 DBUG_PRINT("info", ("event type: %d", event_info->get_type_code()));
7330
7331 /*
7332 No check for auto events flag here - this write method should
7333 never be called if auto-events are enabled.
7334
7335 Write first log events which describe the 'run environment'
7336 of the SQL command. If row-based binlogging, Insert_id, Rand
7337 and other kind of "setting context" events are not needed.
7338 */
7339
1/2
✓ Branch 0 taken 694319 times.
✗ Branch 1 not taken.
 694319 if (thd) {
7340
2/2
✓ Branch 0 taken 391606 times.
✓ Branch 1 taken 302701 times.
 694319 if (!thd->is_current_stmt_binlog_format_row()) {
7341
2/2
✓ Branch 0 taken 185 times.
✓ Branch 1 taken 391421 times.
 391606 if (thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt) {
7342 Intvar_log_event e(
7343 thd, (uchar)binary_log::Intvar_event::LAST_INSERT_ID_EVENT,
7344 thd->first_successful_insert_id_in_prev_stmt_for_binlog,
7345
1/2
✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
 185 event_info->event_cache_type, event_info->event_logging_type);
7346
2/4
✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 185 times.
 185 if (cache_data->write_event(&e)) goto err;
7347
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 184 times.
 185 if (event_info->is_using_immediate_logging())
7348 1 thd->binlog_bytes_written += e.header()->data_written;
7349
1/2
✓ Branch 0 taken 185 times.
✗ Branch 1 not taken.
 185 }
7350
2/2
✓ Branch 0 taken 87334 times.
✓ Branch 1 taken 304123 times.
 391606 if (thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0) {
7351
3/8
✓ Branch 0 taken 87334 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 87334 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 87334 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 87334 DBUG_PRINT(
7352 "info",
7353 ("number of auto_inc intervals: %u",
7354 thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements()));
7355 Intvar_log_event e(
7356 thd, (uchar)binary_log::Intvar_event::INSERT_ID_EVENT,
7357 thd->auto_inc_intervals_in_cur_stmt_for_binlog.minimum(),
7358
1/2
✓ Branch 0 taken 87334 times.
✗ Branch 1 not taken.
 87334 event_info->event_cache_type, event_info->event_logging_type);
7359
2/4
✓ Branch 0 taken 87334 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 87334 times.
 87334 if (cache_data->write_event(&e)) goto err;
7360
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 87266 times.
 87334 if (event_info->is_using_immediate_logging())
7361 68 thd->binlog_bytes_written += e.header()->data_written;
7362
1/2
✓ Branch 0 taken 87334 times.
✗ Branch 1 not taken.
 87334 }
7363
2/2
✓ Branch 0 taken 2098 times.
✓ Branch 1 taken 389359 times.
 391457 if (thd->rand_used) {
7364 2098 Rand_log_event e(thd, thd->rand_saved_seed1, thd->rand_saved_seed2,
7365 event_info->event_cache_type,
7366
1/2
✓ Branch 0 taken 2098 times.
✗ Branch 1 not taken.
 2098 event_info->event_logging_type);
7367
2/4
✓ Branch 0 taken 2098 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2098 times.
 2098 if (cache_data->write_event(&e)) goto err;
7368
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2098 times.
 2098 if (event_info->is_using_immediate_logging())
7369 ✗ thd->binlog_bytes_written += e.header()->data_written;
7370
1/2
✓ Branch 0 taken 2098 times.
✗ Branch 1 not taken.
 2098 }
7371
3/4
✓ Branch 0 taken 391440 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8445 times.
✓ Branch 3 taken 382995 times.
 391457 if (!thd->user_var_events.empty()) {
7372
3/4
✓ Branch 0 taken 16964 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8519 times.
✓ Branch 3 taken 8445 times.
 16964 for (size_t i = 0; i < thd->user_var_events.size(); i++) {
7373
1/2
✓ Branch 0 taken 8519 times.
✗ Branch 1 not taken.
 8519 Binlog_user_var_event *user_var_event = thd->user_var_events[i];
7374
7375 /* setting flags for user var log event */
7376 8519 uchar flags = User_var_log_event::UNDEF_F;
7377
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 8508 times.
 8519 if (user_var_event->unsigned_flag)
7378 11 flags |= User_var_log_event::UNSIGNED_F;
7379
7380 User_var_log_event e(
7381 8519 thd, user_var_event->user_var_event->entry_name.ptr(),
7382 8519 user_var_event->user_var_event->entry_name.length(),
7383 user_var_event->value, user_var_event->length,
7384 user_var_event->type, user_var_event->charset_number, flags,
7385
1/2
✓ Branch 0 taken 8519 times.
✗ Branch 1 not taken.
 8519 event_info->event_cache_type, event_info->event_logging_type);
7386
2/4
✓ Branch 0 taken 8519 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8519 times.
 8519 if (cache_data->write_event(&e)) goto err;
7387
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 8489 times.
 8519 if (event_info->is_using_immediate_logging())
7388 30 thd->binlog_bytes_written += e.header()->data_written;
7389
1/2
✓ Branch 0 taken 8519 times.
✗ Branch 1 not taken.
 8519 }
7390 }
7391 }
7392 }
7393
7394 /*
7395 Write the event.
7396 */
7397
3/4
✓ Branch 0 taken 694309 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 53 times.
✓ Branch 3 taken 694256 times.
 694141 if (cache_data->write_event(event_info)) goto err;
7398
7399
3/4
✓ Branch 0 taken 694274 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 694238 times.
 694256 if (DBUG_EVALUATE_IF("injecting_fault_writing", 1, 0)) goto err;
7400
2/2
✓ Branch 0 taken 103641 times.
✓ Branch 1 taken 590612 times.
 694238 if (event_info->is_using_immediate_logging())
7401 103641 thd->binlog_bytes_written += event_info->common_header->data_written;
7402
7403 /*
7404 After writing the event, if the trx-cache was used and any unsafe
7405 change was written into it, the cache is marked as cannot safely
7406 roll back.
7407 */
7408
7/8
✓ Branch 0 taken 520021 times.
✓ Branch 1 taken 174232 times.
✓ Branch 2 taken 520013 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1160 times.
✓ Branch 5 taken 518853 times.
✓ Branch 6 taken 1160 times.
✓ Branch 7 taken 693085 times.
 694253 if (is_trans_cache && stmt_cannot_safely_rollback(thd))
7409 1160 cache_mngr->trx_cache.set_cannot_rollback();
7410
7411 694237 error = false;
7412
7413 694326 err:
7414
2/2
✓ Branch 0 taken 89 times.
✓ Branch 1 taken 694237 times.
 694326 if (error) {
7415
1/2
✓ Branch 0 taken 89 times.
✗ Branch 1 not taken.
 89 report_cache_write_error(thd, is_trans_cache);
7416
5/8
✓ Branch 0 taken 89 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 89 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 89 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✓ Branch 7 taken 85 times.
 178 if (check_write_error(thd) && cache_data &&
7417
3/4
✓ Branch 0 taken 89 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 85 times.
 89 stmt_cannot_safely_rollback(thd))
7418 4 cache_data->set_incident();
7419 }
7420 }
7421
7422 694248 return error;
7423 824736 }
7424
7425 /**
7426 The method executes rotation when LOCK_log is already acquired
7427 by the caller.
7428
7429 @param force_rotate caller can request the log rotation
7430 @param check_purge is set to true if rotation took place
7431
7432 @note
7433 If rotation fails, for instance the server was unable
7434 to create a new log file, we still try to write an
7435 incident event to the current log.
7436
7437 @note The caller must hold LOCK_log when invoking this function.
7438
7439 @retval
7440 nonzero - error in rotating routine.
7441 */
7442 15035 int MYSQL_BIN_LOG::rotate(bool force_rotate, bool *check_purge) {
7443 15035 int error = 0;
7444
1/2
✓ Branch 0 taken 15035 times.
✗ Branch 1 not taken.
 15035 DBUG_TRACE;
7445
7446
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15035 times.
 15035 assert(!is_relay_log);
7447 15035 mysql_mutex_assert_owner(&LOCK_log);
7448
7449 15035 *check_purge = false;
7450
7451
3/4
✓ Branch 0 taken 15035 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12246 times.
✓ Branch 3 taken 2786 times.
 30067 if (DBUG_EVALUATE_IF("force_rotate", 1, 0) || force_rotate ||
7452
6/6
✓ Branch 0 taken 15032 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 5295 times.
✓ Branch 3 taken 6951 times.
✓ Branch 4 taken 9741 times.
✓ Branch 5 taken 5294 times.
 35362 (m_binlog_file->get_real_file_size() >= (my_off_t)max_size) ||
7453
3/4
✓ Branch 0 taken 5295 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 5294 times.
 5295 DBUG_EVALUATE_IF("simulate_max_binlog_size", true, false)) {
7454
1/2
✓ Branch 0 taken 9726 times.
✗ Branch 1 not taken.
 9741 error = new_file_without_locking(nullptr);
7455 9726 *check_purge = true;
7456
1/2
✓ Branch 0 taken 9726 times.
✗ Branch 1 not taken.
 9726 publish_coordinates_for_global_status();
7457 }
7458 15020 return error;
7459 15020 }
7460
7461 11221 void MYSQL_BIN_LOG::auto_purge_at_server_startup() {
7462 // first run the auto purge validations
7463
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 11215 times.
 11221 if (check_auto_purge_conditions()) return;
7464
7465 11215 auto purge_time = calculate_auto_purge_lower_time_bound();
7466 11215 constexpr auto auto_purge{true};
7467 11215 purge_logs_before_date(purge_time, auto_purge);
7468 }
7469
7470 /**
7471 The method executes logs purging routine.
7472 */
7473 8703 void MYSQL_BIN_LOG::auto_purge() {
7474 // first run the auto purge validations
7475
3/4
✓ Branch 0 taken 8703 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
✓ Branch 3 taken 8680 times.
 8734 if (check_auto_purge_conditions()) return;
7476
7477 // then we run the purge validations
7478 // if we run into out of memory, execute binlog_error_action_abort
7479
1/2
✓ Branch 0 taken 8680 times.
✗ Branch 1 not taken.
 8680 const auto [is_invalid_purge, purge_error] = check_purge_conditions(*this);
7480
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 8649 times.
 8680 if (is_invalid_purge) {
7481
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
 31 if (purge_error == LOG_INFO_MEM) {
7482 /* purecov: begin inspected */
7483 // OOM
7484 ✗ exec_binlog_error_action_abort(
7485 "Out of memory happened while checking if "
7486 "instance was locked for backup");
7487 /* purecov: end */
7488 }
7489 31 return;
7490 }
7491
7492
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8649 times.
 8649 assert(purge_error == 0);
7493
7494
3/6
✓ Branch 0 taken 8649 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8649 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8649 times.
✗ Branch 5 not taken.
 8649 DEBUG_SYNC(current_thd, "at_purge_logs_before_date");
7495
7496
1/2
✓ Branch 0 taken 8649 times.
✗ Branch 1 not taken.
 8649 auto purge_time = calculate_auto_purge_lower_time_bound();
7497 8649 constexpr auto auto_purge{true};
7498 /*
7499 Flush logs for storage engines, so that the last transaction
7500 is persisted inside storage engines.
7501 */
7502
1/2
✓ Branch 0 taken 8649 times.
✗ Branch 1 not taken.
 8649 ha_flush_logs();
7503
1/2
✓ Branch 0 taken 8649 times.
✗ Branch 1 not taken.
 8649 purge_logs_before_date(purge_time, auto_purge);
7504
7505
3/4
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 8607 times.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
 8649 if (binlog_space_limit) purge_logs_by_size(true);
7506 }
7507
7508 /**
7509 Execute a FLUSH LOGS statement.
7510
7511 The method is a shortcut of @c rotate() and @c purge().
7512 LOCK_log is acquired prior to rotate and is released after it.
7513
7514 @param thd Current session.
7515 @param force_rotate caller can request the log rotation
7516
7517 @retval
7518 nonzero - error in rotating routine.
7519 */
7520 1752 int MYSQL_BIN_LOG::rotate_and_purge(THD *thd, bool force_rotate) {
7521 1752 int error = 0;
7522
1/2
✓ Branch 0 taken 1752 times.
✗ Branch 1 not taken.
 1752 DBUG_TRACE;
7523 1752 bool check_purge = false;
7524
7525 /*
7526 FLUSH BINARY LOGS command should ignore 'read-only' and 'super_read_only'
7527 options so that it can update 'mysql.gtid_executed' replication repository
7528 table.
7529 */
7530 1752 thd->set_skip_readonly_check();
7531 /*
7532 Wait for handlerton to insert any pending information into the binlog.
7533 For e.g. ha_ndbcluster which updates the binlog asynchronously this is
7534 needed so that the user see its own commands in the binlog.
7535 */
7536
1/2
✓ Branch 0 taken 1752 times.
✗ Branch 1 not taken.
 1752 ha_binlog_wait(thd);
7537
7538
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1752 times.
 1752 assert(!is_relay_log);
7539
1/2
✓ Branch 0 taken 1752 times.
✗ Branch 1 not taken.
 1752 mysql_mutex_lock(&LOCK_log);
7540
1/2
✓ Branch 0 taken 1737 times.
✗ Branch 1 not taken.
 1752 error = rotate(force_rotate, &check_purge);
7541 /*
7542 NOTE: Run purge_logs wo/ holding LOCK_log because it does not need
7543 the mutex. Otherwise causes various deadlocks.
7544 */
7545
1/2
✓ Branch 0 taken 1737 times.
✗ Branch 1 not taken.
 1737 mysql_mutex_unlock(&LOCK_log);
7546
7547
4/6
✓ Branch 0 taken 1712 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 1712 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1712 times.
✗ Branch 5 not taken.
 1737 if (!error && check_purge) auto_purge();
7548
7549 1737 return error;
7550 1737 }
7551
7552 4133 uint MYSQL_BIN_LOG::next_file_id() {
7553 uint res;
7554 4133 mysql_mutex_lock(&LOCK_log);
7555 4133 res = file_id++;
7556 4133 mysql_mutex_unlock(&LOCK_log);
7557 4133 return res;
7558 }
7559
7560 13774 int MYSQL_BIN_LOG::get_gtid_executed(Sid_map *sid_map, Gtid_set *gtid_set) {
7561
1/2
✓ Branch 0 taken 13774 times.
✗ Branch 1 not taken.
 13774 DBUG_TRACE;
7562 13774 int error = 0;
7563
7564
1/2
✓ Branch 0 taken 13774 times.
✗ Branch 1 not taken.
 13774 mysql_mutex_lock(&mysql_bin_log.LOCK_commit);
7565
1/2
✓ Branch 0 taken 13774 times.
✗ Branch 1 not taken.
 13774 global_sid_lock->wrlock();
7566
7567
1/2
✓ Branch 0 taken 13774 times.
✗ Branch 1 not taken.
 13774 enum_return_status return_status = global_sid_map->copy(sid_map);
7568
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13774 times.
 13774 if (return_status != RETURN_STATUS_OK) {
7569 ✗ error = 1;
7570 ✗ goto end;
7571 }
7572
7573
1/2
✓ Branch 0 taken 13774 times.
✗ Branch 1 not taken.
 13774 return_status = gtid_set->add_gtid_set(gtid_state->get_executed_gtids());
7574
1/2
✓ Branch 0 taken 13774 times.
✗ Branch 1 not taken.
 13774 if (return_status != RETURN_STATUS_OK) error = 1;
7575
7576 13774 end:
7577
1/2
✓ Branch 0 taken 13774 times.
✗ Branch 1 not taken.
 13774 global_sid_lock->unlock();
7578
1/2
✓ Branch 0 taken 13774 times.
✗ Branch 1 not taken.
 13774 mysql_mutex_unlock(&mysql_bin_log.LOCK_commit);
7579
7580 13774 return error;
7581 13774 }
7582
7583 /**
7584 Write the contents of the given IO_CACHE to the binary log.
7585
7586 The cache will be reset as a READ_CACHE to be able to read the
7587 contents from it.
7588
7589 The data will be post-processed: see class Binlog_event_writer for
7590 details.
7591
7592 @param cache Events will be read from this IO_CACHE.
7593 @param writer Events will be written to this Binlog_event_writer.
7594
7595 @retval true IO error.
7596 @retval false Success.
7597
7598 @see MYSQL_BIN_LOG::write_cache
7599 */
7600 5927063 bool MYSQL_BIN_LOG::do_write_cache(Binlog_cache_storage *cache,
7601 Binlog_event_writer *writer) {
7602
1/2
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
 5927063 DBUG_TRACE;
7603
7604
4/6
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 5927062 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 5927063 DBUG_EXECUTE_IF("simulate_do_write_cache_failure", {
7605 /*
7606 see binlog_cache_data::write_event() that reacts on
7607 @c simulate_disk_full_at_flush_pending.
7608 */
7609 DBUG_SET("-d,simulate_do_write_cache_failure");
7610 return true;
7611 });
7612
7613 #ifndef NDEBUG
7614
1/2
✓ Branch 0 taken 5927062 times.
✗ Branch 1 not taken.
 5927062 uint64 expected_total_len = cache->length();
7615
5/8
✓ Branch 0 taken 5927062 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927062 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 106 times.
✓ Branch 5 taken 5926956 times.
✓ Branch 6 taken 106 times.
✗ Branch 7 not taken.
 5927062 DBUG_PRINT("info", ("bytes in cache= %" PRIu64, expected_total_len));
7616 #endif
7617
7618 5927062 bool error = false;
7619
3/4
✓ Branch 0 taken 5927062 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 5927060 times.
 5927062 if (cache->copy_to(writer, &error)) {
7620
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 2 if (error) report_binlog_write_error();
7621 2 return true;
7622 }
7623 5927060 return false;
7624 5927063 }
7625
7626 /**
7627 Writes an incident event to stmt_cache.
7628
7629 @param ev Incident event to be written
7630 @param thd Thread variable
7631 @param need_lock_log If true, will acquire LOCK_log; otherwise the
7632 caller should already have acquired LOCK_log.
7633 @param err_msg Error message written to log file for the incident.
7634 @param do_flush_and_sync If true, will call flush_and_sync(), rotate() and
7635 purge().
7636
7637 @retval false error
7638 @retval true success
7639 */
7640 11 bool MYSQL_BIN_LOG::write_incident(Incident_log_event *ev, THD *thd,
7641 bool need_lock_log, const char *err_msg,
7642 bool do_flush_and_sync) {
7643 11 uint error = 0;
7644
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 DBUG_TRACE;
7645
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 assert(err_msg);
7646
7647
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (!is_open()) return error;
7648
7649
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd);
7650
7651 /*
7652 thd->cache_mngr may be uninitialized when first transaction resulted in an
7653 incident. If there is no cache manager exists for the session, then we
7654 create one, so that a GTID is generated and is written prior to flushing
7655 the stmt_cache.
7656 */
7657
3/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 10 times.
 22 if (cache_mngr == nullptr ||
7658
3/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 10 times.
 11 DBUG_EVALUATE_IF("simulate_cache_creation_failure", 1, 0)) {
7659
3/6
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 2 if (thd->binlog_setup_trx_data() ||
7660
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 DBUG_EVALUATE_IF("simulate_cache_creation_failure", 1, 0)) {
7661
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 auto gtid_mode = global_gtid_mode.get();
7662
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1 if (gtid_mode == Gtid_mode::ON || gtid_mode == Gtid_mode::ON_PERMISSIVE) {
7663
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 std::ostringstream message;
7664
7665 message << "Could not create IO cache while writing an incident event "
7666
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 "to the binary log. Since GTID_MODE = "
7667
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 << gtid_mode
7668
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 << ", server is unable to proceed with logging. Query: '";
7669 /**
7670 The reason for the error may be that the query was
7671 huge. Better cut it to not run into resource problems.
7672 */
7673
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 message.write(thd->query().str, MYSQL_ERRMSG_SIZE);
7674
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 message << "'.";
7675
7676
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 handle_binlog_flush_or_sync_error(thd, true, message.str().c_str());
7677 1 return true;
7678 1 }
7679 } else
7680 ✗ cache_mngr = thd_get_cache_mngr(thd);
7681 }
7682
7683 #ifndef NDEBUG
7684
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
 10 if (DBUG_EVALUATE_IF("simulate_write_incident_event_into_binlog_directly", 1,
7685
4/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 9 times.
 11 0) &&
7686
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 !cache_mngr->stmt_cache.is_binlog_empty()) {
7687 /* The stmt_cache contains corruption data, so we can reset it. */
7688
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 cache_mngr->stmt_cache.reset();
7689 }
7690 #endif
7691
7692 /*
7693 If there is no binlog cache then we write incidents directly
7694 into the binlog. If caller needs GTIDs it has to setup the
7695 binlog cache (for the injector thread).
7696 */
7697
3/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 9 times.
 20 if (cache_mngr == nullptr ||
7698
3/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 9 times.
 10 DBUG_EVALUATE_IF("simulate_write_incident_event_into_binlog_directly", 1,
7699 0)) {
7700
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (need_lock_log)
7701
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 mysql_mutex_lock(&LOCK_log);
7702 else
7703 ✗ mysql_mutex_assert_owner(&LOCK_log);
7704 /* Write an incident event into binlog directly. */
7705
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 error = write_event_to_binlog(ev);
7706 /*
7707 Write an error to log. So that user might have a chance
7708 to be alerted and explore incident details.
7709 */
7710
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (!error)
7711
8/16
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
 1 LogErr(ERROR_LEVEL, ER_BINLOG_LOGGING_INCIDENT_TO_STOP_SLAVES, err_msg);
7712 } else // (cache_mngr != NULL)
7713 {
7714
3/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 3 times.
 9 if (!cache_mngr->stmt_cache.is_binlog_empty()) {
7715 /* The stmt_cache contains corruption data, so we can reset it. */
7716
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 cache_mngr->stmt_cache.reset();
7717 }
7718
3/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 6 times.
 9 if (!cache_mngr->trx_cache.is_binlog_empty()) {
7719 /* The trx_cache contains corruption data, so we can reset it. */
7720
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 cache_mngr->trx_cache.reset();
7721 }
7722 /*
7723 Write the incident event into stmt_cache, so that a GTID is generated and
7724 written for it prior to flushing the stmt_cache.
7725 */
7726 9 binlog_cache_data *cache_data = cache_mngr->get_binlog_cache_data(false);
7727
3/6
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9 times.
 9 if ((error = cache_data->write_event(ev))) {
7728 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_EVENT_WRITE_TO_STMT_CACHE_FAILED);
7729 ✗ cache_mngr->stmt_cache.reset();
7730 ✗ return error;
7731 }
7732
7733
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2 times.
 9 if (need_lock_log)
7734
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 mysql_mutex_lock(&LOCK_log);
7735 else
7736 2 mysql_mutex_assert_owner(&LOCK_log);
7737 }
7738
7739
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
 10 if (do_flush_and_sync) {
7740
4/8
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 8 times.
✗ Branch 7 not taken.
 8 if (!error && !(error = flush_and_sync())) {
7741 8 bool check_purge = false;
7742
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 update_binlog_end_pos();
7743 8 is_rotating_caused_by_incident = true;
7744
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 error = rotate(true, &check_purge);
7745 8 is_rotating_caused_by_incident = false;
7746
3/6
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
 8 if (!error && check_purge) auto_purge();
7747 }
7748 }
7749
7750
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
 10 if (need_lock_log) mysql_mutex_unlock(&LOCK_log);
7751
7752 /*
7753 Write an error to log. So that user might have a chance
7754 to be alerted and explore incident details.
7755 */
7756
2/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
 10 if (!error && cache_mngr != nullptr)
7757
8/16
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 10 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 10 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 10 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 10 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 10 times.
✗ Branch 15 not taken.
 10 LogErr(ERROR_LEVEL, ER_BINLOG_LOGGING_INCIDENT_TO_STOP_SLAVES, err_msg);
7758
7759 10 return error;
7760 11 }
7761
7762 56 bool MYSQL_BIN_LOG::write_stmt_directly(THD *thd, const char *stmt,
7763 size_t stmt_len,
7764 enum_sql_command sql_command) {
7765 56 bool ret = false;
7766 /* backup the original command */
7767 56 enum_sql_command save_sql_command = thd->lex->sql_command;
7768 56 thd->lex->sql_command = sql_command;
7769
7770 56 if (thd->binlog_query(THD::STMT_QUERY_TYPE, stmt, stmt_len, false, false,
7771
2/4
✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 56 times.
 112 false, 0) ||
7772
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
 56 commit(thd, false) != TC_LOG::RESULT_SUCCESS) {
7773 ✗ ret = true;
7774 }
7775
7776 56 thd->lex->sql_command = save_sql_command;
7777 56 return ret;
7778 }
7779
7780 /**
7781 Creates an incident event and writes it to the binary log.
7782
7783 @param thd Thread variable
7784 @param need_lock_log If the binary lock should be locked or not
7785 @param err_msg Error message written to log file for the incident.
7786 @param do_flush_and_sync If true, will call flush_and_sync(), rotate() and
7787 purge().
7788
7789 @retval
7790 0 error
7791 @retval
7792 1 success
7793 */
7794 11 bool MYSQL_BIN_LOG::write_incident(THD *thd, bool need_lock_log,
7795 const char *err_msg,
7796 bool do_flush_and_sync) {
7797
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 DBUG_TRACE;
7798
7799
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (!is_open()) return false;
7800
7801 11 LEX_CSTRING write_error_msg = {err_msg, strlen(err_msg)};
7802 11 binary_log::Incident_event::enum_incident incident =
7803 binary_log::Incident_event::INCIDENT_LOST_EVENTS;
7804
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 Incident_log_event ev(thd, incident, write_error_msg);
7805
7806
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
 11 return write_incident(&ev, thd, need_lock_log, err_msg, do_flush_and_sync);
7807 11 }
7808
7809 /*
7810 Write the event into current binlog directly without going though a session
7811 binlog cache. It will update the event's log_pos and set checksum accordingly.
7812 binary_event_serialize can be called directly if log_pos should not be
7813 updated.
7814 */
7815 221406 inline bool MYSQL_BIN_LOG::write_event_to_binlog(Log_event *ev) {
7816 221406 ev->common_footer->checksum_alg =
7817 221406 is_relay_log
7818
2/2
✓ Branch 0 taken 140715 times.
✓ Branch 1 taken 80691 times.
 221406 ? relay_log_checksum_alg
7819 80691 : static_cast<enum_binlog_checksum_alg>(binlog_checksum_options);
7820
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 221406 times.
 221406 assert(ev->common_footer->checksum_alg !=
7821 binary_log::BINLOG_CHECKSUM_ALG_UNDEF);
7822
7823 /*
7824 Stores current position into log_pos, it is used to calculate correctly
7825 end_log_pos by adding data_written in Log_event::write_header().
7826 */
7827 221406 ev->common_header->log_pos = m_binlog_file->position();
7828
7829
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 221406 times.
 221406 if (binary_event_serialize(ev, m_binlog_file)) return true;
7830
7831 221406 add_bytes_written(ev->common_header->data_written);
7832 221405 return false;
7833 }
7834
7835 /* Write the event into current binlog and flush and sync */
7836 11221 bool MYSQL_BIN_LOG::write_event_to_binlog_and_sync(Log_event *ev) {
7837
3/6
✓ Branch 0 taken 11221 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11221 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 11221 times.
 22442 if (write_event_to_binlog(ev) || m_binlog_file->flush() ||
7838
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11221 times.
 11221 m_binlog_file->sync())
7839 ✗ return true;
7840
7841 11221 update_binlog_end_pos();
7842 11221 return false;
7843 }
7844
7845 /**
7846 Write the contents of the statement or transaction cache to the binary log.
7847
7848 Comparison with do_write_cache:
7849
7850 - do_write_cache is a lower-level function that only performs the
7851 actual write.
7852
7853 - write_cache is a higher-level function that calls do_write_cache
7854 and additionally performs some maintenance tasks, including:
7855 - report any errors that occurred
7856 - write incident event if needed
7857 - update gtid_state
7858 - update thd.binlog_next_event_pos
7859
7860 @param thd Thread variable
7861
7862 @param cache_data Events will be read from the IO_CACHE of this
7863 cache_data object.
7864
7865 @param writer Events will be written to this Binlog_event_writer.
7866
7867 @retval true IO error.
7868 @retval false Success.
7869
7870 @note We only come here if there is something in the cache.
7871 @note Whatever is in the cache is always a complete transaction.
7872 @note 'cache' needs to be reinitialized after this functions returns.
7873 */
7874 5927063 bool MYSQL_BIN_LOG::write_cache(THD *thd, binlog_cache_data *cache_data,
7875 Binlog_event_writer *writer) {
7876
1/2
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
 5927063 DBUG_TRACE;
7877
7878 5927063 Binlog_cache_storage *cache = cache_data->get_cache();
7879 5927063 bool incident = cache_data->has_incident();
7880
7881 5927063 mysql_mutex_assert_owner(&LOCK_log);
7882
7883
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5927063 times.
 5927063 assert(is_open());
7884
1/2
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
 5927063 if (likely(is_open())) // Should always be true
7885 {
7886 /*
7887 We only bother to write to the binary log if there is anything
7888 to write.
7889
7890 @todo Is this check redundant? Probably this is only called if
7891 there is anything in the cache (see @note in comment above this
7892 function). Check if we can replace this by an assertion. /Sven
7893 */
7894
2/4
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5927063 times.
✗ Branch 3 not taken.
 5927063 if (!cache->is_empty()) {
7895
2/28
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5927063 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
 5927063 DBUG_EXECUTE_IF("crash_before_writing_xid", {
7896 if (do_write_cache(cache, writer))
7897 DBUG_PRINT("info", ("error writing binlog cache: %d", write_error));
7898 flush_and_sync(true);
7899 DBUG_PRINT("info", ("crashing before writing xid"));
7900 DBUG_SUICIDE();
7901 });
7902
3/4
✓ Branch 0 taken 5927063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 5927060 times.
 5927063 if (do_write_cache(cache, writer)) goto err;
7903
7904 5927060 const char *err_msg =
7905 "Non-transactional changes did not get into "
7906 "the binlog.";
7907
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5927058 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5927060 times.
 5927062 if (incident &&
7908
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 write_incident(thd, false /*need_lock_log=false*/, err_msg,
7909 false /*do_flush_and_sync==false*/)) {
7910 ✗ report_binlog_write_error();
7911 ✗ goto err;
7912 }
7913
4/6
✓ Branch 0 taken 5927060 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 5927057 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 5927060 DBUG_EXECUTE_IF("half_binlogged_transaction", DBUG_SUICIDE(););
7914 }
7915
1/2
✓ Branch 0 taken 5927057 times.
✗ Branch 1 not taken.
 5927057 update_thd_next_event_pos(thd);
7916 }
7917
7918 5927057 return false;
7919
7920 3 err:
7921 3 thd->commit_error = THD::CE_FLUSH_ERROR;
7922
7923 3 return true;
7924 5927060 }
7925
7926 4 void MYSQL_BIN_LOG::report_binlog_write_error() {
7927 char errbuf[MYSYS_STRERROR_SIZE];
7928
7929 4 write_error = true;
7930
9/18
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 4 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 4 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 4 times.
✗ Branch 17 not taken.
 4 LogErr(ERROR_LEVEL, ER_FAILED_TO_WRITE_TO_FILE, name, errno,
7931 my_strerror(errbuf, sizeof(errbuf), errno));
7932 4 }
7933
7934 /**
7935 Wait until we get a signal that the binary log has been updated.
7936 Applies to master only.
7937
7938 NOTES
7939 @param[in] timeout a pointer to a timespec;
7940 NULL means to wait w/o timeout.
7941 @retval 0 if got signalled on update
7942 @retval non-0 if wait timeout elapsed
7943 @note
7944 LOCK_binlog_end_pos must be taken before calling this function.
7945 LOCK_binlog_end_pos is being released while the thread is waiting.
7946 LOCK_binlog_end_pos is released by the caller.
7947 */
7948
7949 953536 int MYSQL_BIN_LOG::wait_for_update(const struct timespec *timeout) {
7950 953536 int ret = 0;
7951
1/2
✓ Branch 0 taken 953536 times.
✗ Branch 1 not taken.
 953536 DBUG_TRACE;
7952
7953
2/2
✓ Branch 0 taken 139 times.
✓ Branch 1 taken 953397 times.
 953536 if (!timeout)
7954
1/2
✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
 139 mysql_cond_wait(&update_cond, &LOCK_binlog_end_pos);
7955 else
7956
1/2
✓ Branch 0 taken 953246 times.
✗ Branch 1 not taken.
 953397 ret = mysql_cond_timedwait(&update_cond, &LOCK_binlog_end_pos,
7957 const_cast<struct timespec *>(timeout));
7958 953386 return ret;
7959 953385 }
7960
7961 /**
7962 Close the log file.
7963
7964 @param exiting Bitmask for one or more of the following bits:
7965 - LOG_CLOSE_INDEX : if we should close the index file
7966 - LOG_CLOSE_TO_BE_OPENED : if we intend to call open
7967 at once after close.
7968 - LOG_CLOSE_STOP_EVENT : write a 'stop' event to the log
7969
7970 @param need_lock_log If true, this function acquires LOCK_log;
7971 otherwise the caller should already have acquired it.
7972
7973 @param need_lock_index If true, this function acquires LOCK_index;
7974 otherwise the caller should already have acquired it.
7975
7976 @note
7977 One can do an open on the object at once after doing a close.
7978 The internal structures are not freed until cleanup() is called
7979 */
7980
7981 136834 void MYSQL_BIN_LOG::close(
7982 uint exiting, bool need_lock_log,
7983 bool need_lock_index) { // One can't set log_type here!
7984
1/2
✓ Branch 0 taken 136835 times.
✗ Branch 1 not taken.
 136834 DBUG_TRACE;
7985
4/8
✓ Branch 0 taken 136835 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 136835 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 136834 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 136835 DBUG_PRINT("enter", ("exiting: %d", (int)exiting));
7986
2/2
✓ Branch 0 taken 42854 times.
✓ Branch 1 taken 93980 times.
 136834 if (need_lock_log)
7987
1/2
✓ Branch 0 taken 42854 times.
✗ Branch 1 not taken.
 42854 mysql_mutex_lock(&LOCK_log);
7988 else
7989 93980 mysql_mutex_assert_owner(&LOCK_log);
7990
7991
2/2
✓ Branch 0 taken 82555 times.
✓ Branch 1 taken 54280 times.
 136835 if (atomic_log_state == LOG_OPENED) {
7992
2/2
✓ Branch 0 taken 18593 times.
✓ Branch 1 taken 63962 times.
 82555 if ((exiting & LOG_CLOSE_STOP_EVENT) != 0) {
7993 /**
7994 TODO(WL#7546): Change the implementation to Stop_event after write() is
7995 moved into libbinlogevents
7996 */
7997
1/2
✓ Branch 0 taken 18593 times.
✗ Branch 1 not taken.
 18593 Stop_log_event s;
7998 // the checksumming rule for relay-log case is similar to Rotate
7999 18593 s.common_footer->checksum_alg =
8000 18593 is_relay_log
8001
2/2
✓ Branch 0 taken 8914 times.
✓ Branch 1 taken 9679 times.
 18593 ? relay_log_checksum_alg
8002 9679 : static_cast<enum_binlog_checksum_alg>(binlog_checksum_options);
8003
3/4
✓ Branch 0 taken 8914 times.
✓ Branch 1 taken 9679 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8914 times.
 18593 assert(!is_relay_log ||
8004 relay_log_checksum_alg != binary_log::BINLOG_CHECKSUM_ALG_UNDEF);
8005
7/10
✓ Branch 0 taken 18593 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18593 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18593 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 18591 times.
✓ Branch 7 taken 2 times.
✓ Branch 8 taken 18591 times.
✓ Branch 9 taken 2 times.
 18593 if (!write_event_to_binlog(&s) && !m_binlog_file->flush())
8006
1/2
✓ Branch 0 taken 18591 times.
✗ Branch 1 not taken.
 18591 update_binlog_end_pos();
8007 18593 }
8008
8009 /* The following update should not be done in relay log files */
8010
2/2
✓ Branch 0 taken 29162 times.
✓ Branch 1 taken 53393 times.
 82555 if (!is_relay_log) {
8011 29162 my_off_t offset = BIN_LOG_HEADER_SIZE + FLAGS_OFFSET;
8012 29162 uchar flags = 0; // clearing LOG_EVENT_BINLOG_IN_USE_F
8013
1/2
✓ Branch 0 taken 29162 times.
✗ Branch 1 not taken.
 29162 (void)m_binlog_file->update(&flags, 1, offset);
8014 }
8015
8016
6/8
✓ Branch 0 taken 82555 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 82553 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 82553 times.
 82555 if (m_binlog_file->flush_and_sync() && !write_error) {
8017
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 report_binlog_write_error();
8018 }
8019
8020 /*
8021 LOCK_sync to guarantee that no thread is calling m_binlog_file
8022 to sync data to disk when another thread is closing m_binlog_file.
8023 */
8024
3/4
✓ Branch 0 taken 29162 times.
✓ Branch 1 taken 53393 times.
✓ Branch 2 taken 29162 times.
✗ Branch 3 not taken.
 82555 if (!is_relay_log) mysql_mutex_lock(&LOCK_sync);
8025 82555 m_binlog_file->close();
8026
3/4
✓ Branch 0 taken 29162 times.
✓ Branch 1 taken 53393 times.
✓ Branch 2 taken 29162 times.
✗ Branch 3 not taken.
 82555 if (!is_relay_log) mysql_mutex_unlock(&LOCK_sync);
8027
8028 82555 atomic_log_state =
8029
2/2
✓ Branch 0 taken 63931 times.
✓ Branch 1 taken 18624 times.
 82555 (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;
8030
1/2
✓ Branch 0 taken 82555 times.
✗ Branch 1 not taken.
 82555 my_free(name);
8031 82555 name = nullptr;
8032 }
8033
8034 /*
8035 The following test is needed even if is_open() is not set, as we may have
8036 called a not complete close earlier and the index file is still open.
8037 */
8038
8039
2/2
✓ Branch 0 taken 42868 times.
✓ Branch 1 taken 93967 times.
 136835 if (need_lock_index)
8040
1/2
✓ Branch 0 taken 42868 times.
✗ Branch 1 not taken.
 42868 mysql_mutex_lock(&LOCK_index);
8041 else
8042 93967 mysql_mutex_assert_owner(&LOCK_index);
8043
8044
6/6
✓ Branch 0 taken 106848 times.
✓ Branch 1 taken 29987 times.
✓ Branch 2 taken 82764 times.
✓ Branch 3 taken 24084 times.
✓ Branch 4 taken 82764 times.
✓ Branch 5 taken 54071 times.
 136835 if ((exiting & LOG_CLOSE_INDEX) && my_b_inited(&index_file)) {
8045
1/2
✓ Branch 0 taken 82764 times.
✗ Branch 1 not taken.
 82764 end_io_cache(&index_file);
8046
6/8
✓ Branch 0 taken 82764 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 82762 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 82762 times.
 82764 if (mysql_file_close(index_file.file, MYF(0)) < 0 && !write_error) {
8047
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 report_binlog_write_error();
8048 }
8049 }
8050
8051
3/4
✓ Branch 0 taken 42868 times.
✓ Branch 1 taken 93967 times.
✓ Branch 2 taken 42868 times.
✗ Branch 3 not taken.
 136835 if (need_lock_index) mysql_mutex_unlock(&LOCK_index);
8052
8053 136835 atomic_log_state =
8054
2/2
✓ Branch 0 taken 93916 times.
✓ Branch 1 taken 42919 times.
 136835 (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;
8055
1/2
✓ Branch 0 taken 136835 times.
✗ Branch 1 not taken.
 136835 my_free(name);
8056 136835 name = nullptr;
8057
8058
3/4
✓ Branch 0 taken 42854 times.
✓ Branch 1 taken 93981 times.
✓ Branch 2 taken 42854 times.
✗ Branch 3 not taken.
 136835 if (need_lock_log) mysql_mutex_unlock(&LOCK_log);
8059 136835 }
8060
8061 1802860 void MYSQL_BIN_LOG::harvest_bytes_written(Relay_log_info *rli,
8062 bool need_log_space_lock) {
8063 #ifndef NDEBUG
8064 char buf1[22], buf2[22];
8065 #endif
8066
8067
1/2
✓ Branch 0 taken 1802860 times.
✗ Branch 1 not taken.
 1802860 DBUG_TRACE;
8068
2/2
✓ Branch 0 taken 1802828 times.
✓ Branch 1 taken 32 times.
 1802860 if (need_log_space_lock)
8069
1/2
✓ Branch 0 taken 1802828 times.
✗ Branch 1 not taken.
 1802828 mysql_mutex_lock(&rli->log_space_lock);
8070 else
8071 32 mysql_mutex_assert_owner(&rli->log_space_lock);
8072 1802860 rli->log_space_total += bytes_written;
8073
3/12
✓ Branch 0 taken 1802860 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1802860 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1802860 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
 1802860 DBUG_PRINT("info",
8074 ("relay_log_space: %s bytes_written: %s",
8075 llstr(rli->log_space_total, buf1), llstr(bytes_written, buf2)));
8076 1802860 bytes_written = 0;
8077
3/4
✓ Branch 0 taken 1802828 times.
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 1802828 times.
✗ Branch 3 not taken.
 1802860 if (need_log_space_lock) mysql_mutex_unlock(&rli->log_space_lock);
8078 1802860 }
8079
8080 219 void MYSQL_BIN_LOG::set_max_size(ulong max_size_arg) {
8081 /*
8082 We need to take locks, otherwise this may happen:
8083 new_file() is called, calls open(old_max_size), then before open() starts,
8084 set_max_size() sets max_size to max_size_arg, then open() starts and
8085 uses the old_max_size argument, so max_size_arg has been overwritten and
8086 it's like if the SET command was never run.
8087 */
8088
1/2
✓ Branch 0 taken 219 times.
✗ Branch 1 not taken.
 219 DBUG_TRACE;
8089
1/2
✓ Branch 0 taken 219 times.
✗ Branch 1 not taken.
 219 mysql_mutex_lock(&LOCK_log);
8090
2/2
✓ Branch 0 taken 112 times.
✓ Branch 1 taken 107 times.
 219 if (is_open()) max_size = max_size_arg;
8091
1/2
✓ Branch 0 taken 219 times.
✗ Branch 1 not taken.
 219 mysql_mutex_unlock(&LOCK_log);
8092 219 }
8093
8094 /****** transaction coordinator log for 2pc - binlog() based solution ******/
8095
8096 /**
8097 @todo
8098 keep in-memory list of prepared transactions
8099 (add to list in log(), remove on unlog())
8100 and copy it to the new binlog if rotated
8101 but let's check the behaviour of tc_log_page_waits first!
8102 */
8103
8104 11321 int MYSQL_BIN_LOG::open_binlog(const char *opt_name) {
8105 11321 LOG_INFO log_info;
8106 11321 int error = 1;
8107 11321 bool should_execute_ha_recover{false};
8108
8109 /*
8110 This function is used for 2pc transaction coordination. Hence, it
8111 is never used for relay logs.
8112 */
8113
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11321 times.
 11321 assert(!is_relay_log);
8114
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 11321 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 11321 assert(total_ha_2pc > 1 || (1 == total_ha_2pc && opt_bin_log));
8115
2/4
✓ Branch 0 taken 11321 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11321 times.
✗ Branch 3 not taken.
 11321 assert(opt_name && opt_name[0]);
8116
8117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11321 times.
 11321 if (!my_b_inited(&index_file)) {
8118 /* There was a failure to open the index file, can't open the binlog */
8119 ✗ cleanup();
8120 ✗ return 1;
8121 }
8122
8123
3/4
✓ Branch 0 taken 11321 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 11319 times.
 11321 if (using_heuristic_recover()) {
8124 /* generate a new binlog to mask a corrupted one */
8125
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 mysql_mutex_lock(&LOCK_log);
8126
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 open_binlog(opt_name, nullptr, max_binlog_size, false,
8127 true /*need_lock_index=true*/, true /*need_sid_lock=true*/,
8128 nullptr);
8129
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 mysql_mutex_unlock(&LOCK_log);
8130
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 cleanup();
8131 2 return 1;
8132 }
8133
8134
3/4
✓ Branch 0 taken 11319 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5096 times.
✓ Branch 3 taken 6223 times.
 11319 if ((error = find_log_pos(&log_info, NullS, true /*need_lock_index=true*/))) {
8135
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5096 times.
 5096 if (error != LOG_INFO_EOF)
8136 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_FIND_LOG_IN_INDEX, error);
8137 else {
8138 5096 error = 0;
8139 5096 should_execute_ha_recover = true;
8140 }
8141 5096 goto err;
8142 }
8143
8144 {
8145 6223 Log_event *ev = nullptr;
8146 char log_name[FN_REFLEN];
8147 6223 my_off_t valid_pos = 0;
8148 6223 my_off_t binlog_size = 0;
8149
8150 do {
8151
1/2
✓ Branch 0 taken 169908 times.
✗ Branch 1 not taken.
 169908 strmake(log_name, log_info.log_file_name, sizeof(log_name) - 1);
8152 } while (
8153
3/4
✓ Branch 0 taken 169908 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 163685 times.
✓ Branch 3 taken 6223 times.
 169908 !(error = find_next_log(&log_info, true /*need_lock_index=true*/)));
8154
8155
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6223 times.
 6223 if (error != LOG_INFO_EOF) {
8156 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_FIND_LOG_IN_INDEX, error);
8157 4512 goto err;
8158 }
8159
8160
1/2
✓ Branch 0 taken 6223 times.
✗ Branch 1 not taken.
 6223 Binlog_file_reader binlog_file_reader(opt_source_verify_checksum);
8161
3/4
✓ Branch 0 taken 6223 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 6210 times.
 6223 if (binlog_file_reader.open(log_name)) {
8162
9/18
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 13 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 13 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 13 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 13 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 13 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 13 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 13 times.
✗ Branch 17 not taken.
 13 LogErr(ERROR_LEVEL, ER_BINLOG_FILE_OPEN_FAILED,
8163 binlog_file_reader.get_error_str());
8164 13 goto err;
8165 }
8166
8167 /*
8168 If the binary log was not properly closed it means that the server
8169 may have crashed. In that case, we need to call
8170 binlog::Binlog_recovery::recover()
8171 to:
8172
8173 a) collect logged XIDs;
8174 b) complete the 2PC of the pending XIDs;
8175 c) collect the last valid position.
8176
8177 Therefore, we do need to iterate over the binary log, even if
8178 total_ha_2pc == 1, to find the last valid group of events written.
8179 Later we will take this value and truncate the log if need be.
8180 */
8181
2/4
✓ Branch 0 taken 6210 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6210 times.
✗ Branch 3 not taken.
 12420 if ((ev = binlog_file_reader.read_event_object()) &&
8182
3/4
✓ Branch 0 taken 6210 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1774 times.
✓ Branch 3 taken 4436 times.
 12420 ev->get_type_code() == binary_log::FORMAT_DESCRIPTION_EVENT &&
8183
2/2
✓ Branch 0 taken 4436 times.
✓ Branch 1 taken 1774 times.
 6210 (ev->common_header->flags & LOG_EVENT_BINLOG_IN_USE_F ||
8184
2/4
✓ Branch 0 taken 4436 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4436 times.
 4436 DBUG_EVALUATE_IF("eval_force_bin_log_recovery", true, false))) {
8185
8/16
✓ Branch 0 taken 1774 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1774 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1774 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1774 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1774 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1774 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1774 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1774 times.
✗ Branch 15 not taken.
 1774 LogErr(INFORMATION_LEVEL, ER_BINLOG_RECOVERING_AFTER_CRASH_USING,
8186 opt_name);
8187
1/2
✓ Branch 0 taken 1774 times.
✗ Branch 1 not taken.
 1774 binlog::Binlog_recovery bl_recovery{binlog_file_reader};
8188 1774 error = bl_recovery //
8189
1/2
✓ Branch 0 taken 1774 times.
✗ Branch 1 not taken.
 1774 .recover() //
8190
1/2
✓ Branch 0 taken 1774 times.
✗ Branch 1 not taken.
 1774 .has_failures();
8191
1/2
✓ Branch 0 taken 1774 times.
✗ Branch 1 not taken.
 1774 valid_pos = bl_recovery.get_valid_pos();
8192
1/2
✓ Branch 0 taken 1774 times.
✗ Branch 1 not taken.
 1774 binlog_size = binlog_file_reader.ifile()->length();
8193
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 1711 times.
 1774 if (error) {
8194
3/4
✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 48 times.
 63 if (bl_recovery.is_binlog_malformed())
8195
9/18
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 15 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 15 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 15 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 15 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 15 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 15 times.
✗ Branch 17 not taken.
 15 LogErr(ERROR_LEVEL, ER_BINLOG_CRASH_RECOVERY_MALFORMED_LOG, log_name,
8196 valid_pos, binlog_file_reader.position(),
8197 bl_recovery.get_failure_message().data());
8198
3/4
✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 48 times.
✓ Branch 3 taken 15 times.
 63 if (bl_recovery.has_engine_recovery_failed())
8199
8/16
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 48 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 48 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 48 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 48 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 48 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 48 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 48 times.
✗ Branch 15 not taken.
 48 LogErr(ERROR_LEVEL, ER_BINLOG_CRASH_RECOVERY_ERROR_RETURNED_SE);
8200 }
8201 1774 } else
8202 4436 should_execute_ha_recover = true;
8203
8204
1/2
✓ Branch 0 taken 6210 times.
✗ Branch 1 not taken.
 6210 delete ev;
8205
8206
2/2
✓ Branch 0 taken 4499 times.
✓ Branch 1 taken 1711 times.
 6210 if (error) goto err;
8207
8208 /* Trim the crashed binlog file to last valid transaction
8209 or event (non-transaction) base on valid_pos. */
8210
1/2
✓ Branch 0 taken 1711 times.
✗ Branch 1 not taken.
 1711 if (valid_pos > 0) {
8211 std::unique_ptr<Binlog_ofile> ofile(
8212
1/2
✓ Branch 0 taken 1711 times.
✗ Branch 1 not taken.
 1711 Binlog_ofile::open_existing(key_file_binlog, log_name, MYF(MY_WME)));
8213
8214
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1711 times.
 1711 if (!ofile) {
8215 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_CRASHED_BINLOG);
8216 ✗ return -1;
8217 }
8218
8219 /* Change binlog file size to valid_pos */
8220
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1705 times.
 1711 if (valid_pos < binlog_size) {
8221
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
 6 if (ofile->truncate(valid_pos)) {
8222 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_CANT_TRIM_CRASHED_BINLOG);
8223 ✗ return -1;
8224 }
8225
8/16
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6 times.
✗ Branch 15 not taken.
 6 LogErr(INFORMATION_LEVEL, ER_BINLOG_CRASHED_BINLOG_TRIMMED, log_name,
8226 binlog_size, valid_pos, valid_pos);
8227 }
8228
8229 /* Clear LOG_EVENT_BINLOG_IN_USE_F */
8230 1711 uchar flags = 0;
8231
2/4
✓ Branch 0 taken 1711 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1711 times.
 1711 if (ofile->update(&flags, 1, BIN_LOG_HEADER_SIZE + FLAGS_OFFSET)) {
8232 ✗ LogErr(ERROR_LEVEL,
8233 ER_BINLOG_CANT_CLEAR_IN_USE_FLAG_FOR_CRASHED_BINLOG);
8234 ✗ return -1;
8235 }
8236
1/2
✓ Branch 0 taken 1711 times.
✗ Branch 1 not taken.
 1711 } // end if (valid_pos > 0)
8237
2/3
✓ Branch 0 taken 1711 times.
✓ Branch 1 taken 4512 times.
✗ Branch 2 not taken.
 6223 }
8238
8239 11319 err:
8240
2/2
✓ Branch 0 taken 9532 times.
✓ Branch 1 taken 1787 times.
 11319 if (should_execute_ha_recover) {
8241
1/2
✓ Branch 0 taken 9532 times.
✗ Branch 1 not taken.
 9532 error = ha_recover();
8242
1/18
✗ Branch 0 not taken.
✓ Branch 1 taken 9532 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
 9532 if (error) LogErr(ERROR_LEVEL, ER_BINLOG_CRASH_RECOVERY_ERROR_RETURNED_SE);
8243 }
8244 11319 return error;
8245 }
8246
8247 /**
8248 Truncate the active relay log file in the specified position.
8249
8250 @param mi Master_info of the channel going to truncate the relay log file.
8251 @param truncate_pos The position to truncate the active relay log file.
8252 @return False on success and true on failure.
8253 */
8254 6 bool MYSQL_BIN_LOG::truncate_relaylog_file(Master_info *mi,
8255 my_off_t truncate_pos) {
8256
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 DBUG_TRACE;
8257
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 assert(is_relay_log);
8258 6 mysql_mutex_assert_owner(&LOCK_log);
8259 6 Relay_log_info *rli = mi->rli;
8260 6 bool error = false;
8261
8262 /*
8263 If the relay log was closed by an error (binlog_error_action=IGNORE_ERROR)
8264 this truncate function should produce no result as the relay log is already
8265 in really bad shape.
8266 */
8267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!is_open()) {
8268 ✗ return false;
8269 }
8270
8271 6 my_off_t relaylog_file_size = m_binlog_file->position();
8272
8273
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 6 if (truncate_pos > 0 && truncate_pos < relaylog_file_size) {
8274
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
 6 if (m_binlog_file->truncate(truncate_pos)) {
8275 ✗ mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
8276 ✗ ER_THD(current_thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
8277 "failed to truncate relay log file");
8278 ✗ error = true;
8279 } else {
8280
8/16
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6 times.
✗ Branch 15 not taken.
 6 LogErr(INFORMATION_LEVEL, ER_SLAVE_RELAY_LOG_TRUNCATE_INFO, log_file_name,
8281 relaylog_file_size, truncate_pos);
8282
8283 // Re-init the SQL thread IO_CACHE
8284
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
 6 assert(strcmp(rli->get_event_relay_log_name(), log_file_name) ||
8285 rli->get_event_relay_log_pos() <= truncate_pos);
8286
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 rli->notify_relay_log_truncated();
8287 }
8288 }
8289 6 return error;
8290 6 }
8291
8292 /** This is called on shutdown, after ha_panic. */
8293 ✗ void MYSQL_BIN_LOG::close() {}
8294
8295 /*
8296 Prepare the transaction in the transaction coordinator.
8297
8298 This function will prepare the transaction in the storage engines
8299 (by calling @c ha_prepare_low) what will write a prepare record
8300 to the log buffers.
8301
8302 @retval 0 success
8303 @retval 1 error
8304 */
8305 11112138 int MYSQL_BIN_LOG::prepare(THD *thd, bool all) {
8306
1/2
✓ Branch 0 taken 11112682 times.
✗ Branch 1 not taken.
 11112138 DBUG_TRACE;
8307
8308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11112682 times.
 11112682 assert(opt_bin_log);
8309
8310 /*
8311 Set HA_IGNORE_DURABILITY to not flush the prepared record of the
8312 transaction to the log of storage engine (for example, InnoDB
8313 redo log) during the prepare phase. So that we can flush prepared
8314 records of transactions to the log of storage engine in a group
8315 right before flushing them to binary log during binlog group
8316 commit flush stage. Reset to HA_REGULAR_DURABILITY at the
8317 beginning of parsing next command.
8318 */
8319 11112682 thd->durability_property = HA_IGNORE_DURABILITY;
8320
8321
2/4
✓ Branch 0 taken 11112719 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11112625 times.
✗ Branch 3 not taken.
 11112682 CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_prepare_in_engines");
8322
1/2
✓ Branch 0 taken 11112691 times.
✗ Branch 1 not taken.
 11112763 int error = ha_prepare_low(thd, all);
8323
8324
2/4
✓ Branch 0 taken 11112773 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11112828 times.
✗ Branch 3 not taken.
 11112691 CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("after_ha_prepare_low");
8325 // Invoke `commit` if we're dealing with `XA PREPARE` in order to use BCG
8326 // to write the event to file.
8327
10/12
✓ Branch 0 taken 11112531 times.
✓ Branch 1 taken 291 times.
✓ Branch 2 taken 501073 times.
✓ Branch 3 taken 10611458 times.
✓ Branch 4 taken 501072 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 571 times.
✓ Branch 7 taken 500501 times.
✓ Branch 8 taken 571 times.
✓ Branch 9 taken 11112250 times.
✓ Branch 10 taken 568 times.
✗ Branch 11 not taken.
 11112822 if (!error && all && is_xa_prepare(thd)) return this->commit(thd, true);
8328
8329 11112250 return error;
8330 11112818 }
8331
8332 /**
8333 Commit the transaction in the transaction coordinator.
8334
8335 This function will commit the sessions transaction in the binary log
8336 and in the storage engines (by calling @c ha_commit_low). If the
8337 transaction was successfully logged (or not successfully unlogged)
8338 but the commit in the engines did not succeed, there is a risk of
8339 inconsistency between the engines and the binary log.
8340
8341 For binary log group commit, the commit is separated into three
8342 parts:
8343
8344 1. First part consists of filling the necessary caches and
8345 finalizing them (if they need to be finalized). After this,
8346 nothing is added to any of the caches.
8347
8348 2. Second part execute an ordered flush and commit. This will be
8349 done using the group commit functionality in ordered_commit.
8350
8351 3. Third part checks any errors resulting from the ordered commit
8352 and handles them appropriately.
8353
8354 @retval RESULT_SUCCESS success
8355 @retval RESULT_ABORTED error, transaction was neither logged nor committed
8356 @retval RESULT_INCONSISTENT error, transaction was logged but not committed
8357 */
8358 39471675 TC_LOG::enum_result MYSQL_BIN_LOG::commit(THD *thd, bool all) {
8359
1/2
✓ Branch 0 taken 39474548 times.
✗ Branch 1 not taken.
 39471675 DBUG_TRACE;
8360
8/14
✓ Branch 0 taken 39473777 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39474178 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 604 times.
✓ Branch 5 taken 39473574 times.
✓ Branch 6 taken 604 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 604 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 604 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 604 times.
✗ Branch 13 not taken.
 39474548 DBUG_PRINT("info",
8361 ("query='%s'", thd == current_thd ? thd->query().str : nullptr));
8362 39474178 Transaction_ctx *trn_ctx = thd->get_transaction();
8363
1/2
✓ Branch 0 taken 39473046 times.
✗ Branch 1 not taken.
 39473651 my_xid xid = trn_ctx->xid_state()->get_xid()->get_my_xid();
8364 39473046 bool stmt_stuff_logged = false;
8365 39473046 bool trx_stuff_logged = false;
8366
1/2
✓ Branch 0 taken 39473845 times.
✗ Branch 1 not taken.
 39473046 bool skip_commit = is_loggable_xa_prepare(thd);
8367 39473845 bool is_atomic_ddl = false;
8368 39473845 auto xs = thd->get_transaction()->xid_state();
8369 39472552 raii::Sentry<> reset_detached_guard{[&]() -> void {
8370 // XID_STATE may have been used to hold metadata for a detached transaction.
8371 // In that case, we need to reset it.
8372
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39473270 times.
 39472552 if (xs->is_detached()) xs->reset();
8373
1/2
✓ Branch 0 taken 39472930 times.
✗ Branch 1 not taken.
 39474400 }};
8374
8375
2/2
✓ Branch 0 taken 1082 times.
✓ Branch 1 taken 39471906 times.
 39472988 if (thd->lex->sql_command ==
8376 SQLCOM_XA_COMMIT) { // XA commit must be written to the binary log prior
8377 // to retrieving cache manager
8378
2/4
✓ Branch 0 taken 1082 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1082 times.
 1082 if (this->write_xa_to_cache(thd)) return RESULT_ABORTED;
8379 }
8380
8381
1/2
✓ Branch 0 taken 39473416 times.
✗ Branch 1 not taken.
 39472988 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd);
8382
7/10
✓ Branch 0 taken 39473217 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39473513 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 596 times.
✓ Branch 5 taken 39472917 times.
✓ Branch 6 taken 287 times.
✓ Branch 7 taken 309 times.
✓ Branch 8 taken 655 times.
✗ Branch 9 not taken.
 39473416 DBUG_PRINT("enter", ("thd: 0x%llx, all: %s, xid: %llu, cache_mngr: 0x%llx",
8383 (ulonglong)thd, YESNO(all), (ulonglong)xid,
8384 (ulonglong)cache_mngr));
8385
8386 /*
8387 No cache manager means nothing to log, but we still have to commit
8388 the transaction.
8389 */
8390
2/2
✓ Branch 0 taken 10726980 times.
✓ Branch 1 taken 28746598 times.
 39473578 if (cache_mngr == nullptr) {
8391
7/8
✓ Branch 0 taken 10726922 times.
✓ Branch 1 taken 58 times.
✓ Branch 2 taken 10726844 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 10726841 times.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 10726899 times.
 10726980 if (!skip_commit && trx_coordinator::commit_in_engines(thd, all))
8392 3 return RESULT_ABORTED;
8393 10726899 return RESULT_SUCCESS;
8394 }
8395
8396 /*
8397 Reset binlog_snapshot_% variables for the current connection so that the
8398 current coordinates are shown after committing a consistent snapshot
8399 transaction.
8400 */
8401
2/2
✓ Branch 0 taken 1874746 times.
✓ Branch 1 taken 26871852 times.
 28746598 if (all) {
8402
1/2
✓ Branch 0 taken 1874760 times.
✗ Branch 1 not taken.
 1874746 mysql_mutex_lock(&thd->LOCK_thd_data);
8403 1874760 cache_mngr->drop_consistent_snapshot();
8404
1/2
✓ Branch 0 taken 1874565 times.
✗ Branch 1 not taken.
 1874775 mysql_mutex_unlock(&thd->LOCK_thd_data);
8405 }
8406
8407 28746417 Transaction_ctx::enum_trx_scope trx_scope =
8408
2/2
✓ Branch 0 taken 1874788 times.
✓ Branch 1 taken 26871629 times.
 28746417 all ? Transaction_ctx::SESSION : Transaction_ctx::STMT;
8409
8410
8/12
✓ Branch 0 taken 28746701 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28746861 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 586 times.
✓ Branch 5 taken 28746275 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 586 times.
✓ Branch 8 taken 563 times.
✓ Branch 9 taken 23 times.
✓ Branch 10 taken 586 times.
✗ Branch 11 not taken.
 28746417 DBUG_PRINT("debug", ("in_transaction: %s, no_2pc: %s, rw_ha_count: %d",
8411 YESNO(thd->in_multi_stmt_transaction_mode()),
8412 YESNO(trn_ctx->no_2pc(trx_scope)),
8413 trn_ctx->rw_ha_count(trx_scope)));
8414
10/14
✓ Branch 0 taken 28746816 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28746918 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 586 times.
✓ Branch 5 taken 28746332 times.
✓ Branch 6 taken 586 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 414 times.
✓ Branch 9 taken 172 times.
✓ Branch 10 taken 16 times.
✓ Branch 11 taken 570 times.
✓ Branch 12 taken 586 times.
✗ Branch 13 not taken.
 28746861 DBUG_PRINT("debug",
8415 ("all.cannot_safely_rollback(): %s, trx_cache_empty: %s",
8416 YESNO(trn_ctx->cannot_safely_rollback(Transaction_ctx::SESSION)),
8417 YESNO(cache_mngr->trx_cache.is_binlog_empty())));
8418
10/14
✓ Branch 0 taken 28746886 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28746969 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 586 times.
✓ Branch 5 taken 28746383 times.
✓ Branch 6 taken 586 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 562 times.
✓ Branch 9 taken 24 times.
✓ Branch 10 taken 9 times.
✓ Branch 11 taken 577 times.
✓ Branch 12 taken 284 times.
✗ Branch 13 not taken.
 28746918 DBUG_PRINT("debug",
8419 ("stmt.cannot_safely_rollback(): %s, stmt_cache_empty: %s",
8420 YESNO(trn_ctx->cannot_safely_rollback(Transaction_ctx::STMT)),
8421 YESNO(cache_mngr->stmt_cache.is_binlog_empty())));
8422
8423 /*
8424 If there are no handlertons registered, there is nothing to
8425 commit. Note that DDLs are written earlier in this case (inside
8426 binlog_query).
8427
8428 TODO: This can be a problem in those cases that there are no
8429 handlertons registered. DDLs are one example, but the other case
8430 is MyISAM. In this case, we could register a dummy handlerton to
8431 trigger the commit.
8432
8433 Any statement that requires logging will call binlog_query before
8434 trans_commit_stmt, so an alternative is to use the condition
8435 "binlog_query called or stmt.ha_list != 0".
8436 */
8437
6/6
✓ Branch 0 taken 26872010 times.
✓ Branch 1 taken 1874659 times.
✓ Branch 2 taken 14795863 times.
✓ Branch 3 taken 12076154 times.
✓ Branch 4 taken 14696967 times.
✓ Branch 5 taken 14049882 times.
 43542705 if (!all && !trn_ctx->is_active(trx_scope) &&
8438
3/4
✓ Branch 0 taken 14796036 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14697023 times.
✓ Branch 3 taken 99013 times.
 14795863 cache_mngr->stmt_cache.is_binlog_empty())
8439 14696967 return RESULT_SUCCESS;
8440
8441
3/4
✓ Branch 0 taken 14050026 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 480856 times.
✓ Branch 3 taken 13569170 times.
 14049882 if (!cache_mngr->stmt_cache.is_binlog_empty()) {
8442 /*
8443 Commit parent identification of non-transactional query has
8444 been deferred until now, except for the mixed transaction case.
8445 */
8446
1/2
✓ Branch 0 taken 480912 times.
✗ Branch 1 not taken.
 480856 trn_ctx->store_commit_parent(
8447 m_dependency_tracker.get_max_committed_timestamp());
8448
2/4
✓ Branch 0 taken 480887 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 480887 times.
 480567 if (cache_mngr->stmt_cache.finalize(thd)) return RESULT_ABORTED;
8449 480887 stmt_stuff_logged = true;
8450 }
8451
8452 /*
8453 We commit the transaction if:
8454 - We are not in a transaction and committing a statement, or
8455 - We are in a transaction and a full transaction is committed.
8456 Otherwise, we accumulate the changes.
8457 */
8458
8/10
✓ Branch 0 taken 14050155 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11410165 times.
✓ Branch 3 taken 2639990 times.
✓ Branch 4 taken 11410214 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5445456 times.
✓ Branch 7 taken 5964758 times.
✓ Branch 8 taken 5445461 times.
✓ Branch 9 taken 8604743 times.
 19495513 if (!cache_mngr->trx_cache.is_binlog_empty() && ending_trans(thd, all) &&
8459
1/2
✓ Branch 0 taken 5445462 times.
✗ Branch 1 not taken.
 5445456 !trx_stuff_logged) {
8460 const bool real_trans =
8461
3/4
✓ Branch 0 taken 4891938 times.
✓ Branch 1 taken 553523 times.
✓ Branch 2 taken 4891943 times.
✗ Branch 3 not taken.
 5445461 (all || !trn_ctx->is_active(Transaction_ctx::SESSION));
8462
8463
1/2
✓ Branch 0 taken 5445412 times.
✗ Branch 1 not taken.
 5445462 bool one_phase = get_xa_opt(thd) == XA_ONE_PHASE;
8464
1/2
✓ Branch 0 taken 5445381 times.
✗ Branch 1 not taken.
 5445412 bool is_loggable_xa = is_loggable_xa_prepare(thd);
8465
8466 /*
8467 Log and finalize transaction cache regarding XA PREPARE/XA COMMIT ONE
8468 PHASE if one of the following statements is true:
8469 - If it is a loggable XA transaction in prepare state;
8470 - If it is a transaction being committed with 'XA COMMIT ONE PHASE',
8471 statement and is not an empty transaction when GTID_NEXT is set to a
8472 manual GTID.
8473
8474 For other XA COMMIT ONE PHASE statements that already have been finalized
8475 or are finalizing empty transactions when GTID_NEXT is set to a manual
8476 GTID, just let the execution flow get into the final 'else' branch and log
8477 a final 'COMMIT;' statement.
8478 */
8479
4/4
✓ Branch 0 taken 5444845 times.
✓ Branch 1 taken 536 times.
✓ Branch 2 taken 634 times.
✓ Branch 3 taken 5444747 times.
 10890226 if (is_loggable_xa || // XA transaction in prepare state
8480
3/4
✓ Branch 0 taken 101 times.
✓ Branch 1 taken 5444744 times.
✓ Branch 2 taken 101 times.
✗ Branch 3 not taken.
 5444845 (thd->lex->sql_command == SQLCOM_XA_COMMIT && // Is a 'XA COMMIT
8481 101 one_phase && // ONE PHASE'
8482
1/2
✓ Branch 0 taken 101 times.
✗ Branch 1 not taken.
 101 xs != nullptr && // and it has not yet
8483
1/2
✓ Branch 0 taken 101 times.
✗ Branch 1 not taken.
 101 !xs->is_binlogged() && // been logged
8484
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 86 times.
 101 (thd->owned_gtid.sidno <= 0 || // and GTID_NEXT is NOT set to a
8485 // manual GTID
8486
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 3 times.
 15 !xs->has_state(XID_STATE::XA_NOTR)))) // and the transaction is NOT
8487 // empty and NOT finalized in
8488 // 'trans_xa_commit'
8489 {
8490 /* The prepare phase of XA transaction two phase logging. */
8491 634 int err = 0;
8492
8493
3/4
✓ Branch 0 taken 98 times.
✓ Branch 1 taken 536 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 98 times.
 634 assert(thd->lex->sql_command != SQLCOM_XA_COMMIT || one_phase);
8494
8495
1/2
✓ Branch 0 taken 634 times.
✗ Branch 1 not taken.
 634 XA_prepare_log_event end_evt(thd, xs->get_xid(), one_phase);
8496
8497
3/4
✓ Branch 0 taken 536 times.
✓ Branch 1 taken 98 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 536 times.
 634 assert(!is_loggable_xa || skip_commit);
8498
8499
1/2
✓ Branch 0 taken 634 times.
✗ Branch 1 not taken.
 634 err = cache_mngr->trx_cache.finalize(thd, &end_evt, xs);
8500
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 634 times.
 634 if (err) return RESULT_ABORTED;
8501
2/2
✓ Branch 0 taken 536 times.
✓ Branch 1 taken 98 times.
 634 if (is_loggable_xa)
8502
3/4
✓ Branch 0 taken 536 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 530 times.
 536 if (DBUG_EVALUATE_IF("simulate_xa_prepare_failure_in_cache_finalize",
8503 true, false))
8504 6 return RESULT_ABORTED;
8505
2/2
✓ Branch 0 taken 628 times.
✓ Branch 1 taken 6 times.
 634 }
8506 /*
8507 If is atomic DDL, finalize cache for DDL and no further logging is needed.
8508 */
8509
2/2
✓ Branch 0 taken 265647 times.
✓ Branch 1 taken 5179026 times.
 5444747 else if ((is_atomic_ddl = cache_mngr->trx_cache.has_xid())) {
8510
2/4
✓ Branch 0 taken 265647 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 265647 times.
 265647 if (cache_mngr->trx_cache.finalize(thd, nullptr)) return RESULT_ABORTED;
8511 }
8512 /*
8513 We are committing a 2PC transaction if it is a "real" transaction
8514 and has an XID assigned (because some handlerton registered). A
8515 transaction is "real" if either 'all' is true or
8516 'trn_ctx->is_active(Transaction_ctx::SESSION)' is not true.
8517
8518 Note: This is kind of strange since registering the binlog
8519 handlerton will then make the transaction 2PC, which is not really
8520 true. This occurs for example if a MyISAM statement is executed
8521 with row-based replication on.
8522 */
8523
8/8
✓ Branch 0 taken 5179023 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 5148953 times.
✓ Branch 3 taken 30070 times.
✓ Branch 4 taken 5119962 times.
✓ Branch 5 taken 29001 times.
✓ Branch 6 taken 5119957 times.
✓ Branch 7 taken 59067 times.
 10298976 else if (real_trans && xid && trn_ctx->rw_ha_count(trx_scope) > 1 &&
8524
2/2
✓ Branch 0 taken 5119936 times.
✓ Branch 1 taken 14 times.
 5119962 !trn_ctx->no_2pc(trx_scope)) {
8525
1/2
✓ Branch 0 taken 5119978 times.
✗ Branch 1 not taken.
 5119957 Xid_log_event end_evt(thd, xid);
8526
2/4
✓ Branch 0 taken 5120162 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5120162 times.
 5119978 if (cache_mngr->trx_cache.finalize(thd, &end_evt)) return RESULT_ABORTED;
8527
1/2
✓ Branch 0 taken 5120010 times.
✗ Branch 1 not taken.
 5120162 }
8528 /*
8529 No further action needed and no special case applies, log a final
8530 'COMMIT' statement and finalize the transaction cache.
8531
8532 Empty transactions finalized with 'XA COMMIT ONE PHASE' will be covered
8533 by this branch.
8534 */
8535 else {
8536 Query_log_event end_evt(thd, STRING_WITH_LEN("COMMIT"), true, false, true,
8537
1/2
✓ Branch 0 taken 59088 times.
✗ Branch 1 not taken.
 59067 0, true);
8538
2/4
✓ Branch 0 taken 59088 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 59088 times.
 59088 if (cache_mngr->trx_cache.finalize(thd, &end_evt)) return RESULT_ABORTED;
8539
1/2
✓ Branch 0 taken 59088 times.
✗ Branch 1 not taken.
 59088 }
8540 5445373 trx_stuff_logged = true;
8541 }
8542
8543 /*
8544 This is part of the stmt rollback.
8545 */
8546
3/4
✓ Branch 0 taken 12175171 times.
✓ Branch 1 taken 1874945 times.
✓ Branch 2 taken 12175453 times.
✗ Branch 3 not taken.
 14050116 if (!all) cache_mngr->trx_cache.set_prev_position(MY_OFF_T_UNDEF);
8547
8548 /*
8549 Now all the events are written to the caches, so we will commit
8550 the transaction in the engines. This is done using the group
8551 commit logic in ordered_commit, which will return when the
8552 transaction is committed.
8553
8554 If the commit in the engines fail, we still have something logged
8555 to the binary log so we have to report this as a "bad" failure
8556 (failed to commit, but logged something).
8557 */
8558
4/4
✓ Branch 0 taken 13569281 times.
✓ Branch 1 taken 481117 times.
✓ Branch 2 taken 5444887 times.
✓ Branch 3 taken 8124394 times.
 14050398 if (stmt_stuff_logged || trx_stuff_logged) {
8559
2/4
✓ Branch 0 taken 5925680 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5925756 times.
✗ Branch 3 not taken.
 5926004 CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_invoke_before_commit_hook");
8560
6/10
✓ Branch 0 taken 5925400 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5821673 times.
✓ Branch 3 taken 103727 times.
✓ Branch 4 taken 103771 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 103845 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 103851 times.
✗ Branch 9 not taken.
 5925843 if (RUN_HOOK(
8561 transaction, before_commit,
8562 (thd, all, thd_get_cache_mngr(thd)->get_trx_cache(),
8563 thd_get_cache_mngr(thd)->get_stmt_cache(),
8564 max<my_off_t>(max_binlog_cache_size, max_binlog_stmt_cache_size),
8565
4/4
✓ Branch 0 taken 5925381 times.
✓ Branch 1 taken 143 times.
✓ Branch 2 taken 44 times.
✓ Branch 3 taken 5925586 times.
 11851011 is_atomic_ddl)) ||
8566
2/4
✓ Branch 0 taken 5925487 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5925497 times.
 5925381 DBUG_EVALUATE_IF("simulate_failure_in_before_commit_hook", true,
8567 false)) {
8568
1/2
✓ Branch 0 taken 44 times.
✗ Branch 1 not taken.
 44 trx_coordinator::rollback_in_engines(thd, all);
8569
1/2
✓ Branch 0 taken 44 times.
✗ Branch 1 not taken.
 44 gtid_state->update_on_rollback(thd);
8570
2/4
✓ Branch 0 taken 44 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 44 times.
✗ Branch 3 not taken.
 44 thd_get_cache_mngr(thd)->reset();
8571 // Reset the thread OK status before changing the outcome.
8572
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 15 times.
 44 if (thd->get_stmt_da()->is_ok())
8573
1/2
✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
 29 thd->get_stmt_da()->reset_diagnostics_area();
8574
1/2
✓ Branch 0 taken 44 times.
✗ Branch 1 not taken.
 44 my_error(ER_RUN_HOOK_ERROR, MYF(0), "before_commit");
8575 44 return RESULT_ABORTED;
8576 }
8577 /*
8578 Check whether the transaction should commit or abort given the
8579 plugin feedback.
8580 */
8581 5925681 if (thd->get_transaction()
8582 ->get_rpl_transaction_ctx()
8583
5/6
✓ Branch 0 taken 5925755 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5925112 times.
✓ Branch 3 taken 643 times.
✓ Branch 4 taken 645 times.
✓ Branch 5 taken 5925036 times.
 11850624 ->is_transaction_rollback() ||
8584
3/4
✓ Branch 0 taken 5925038 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 5925036 times.
 5925112 (DBUG_EVALUATE_IF("simulate_transaction_rollback_request", true,
8585 false))) {
8586
1/2
✓ Branch 0 taken 645 times.
✗ Branch 1 not taken.
 645 trx_coordinator::rollback_in_engines(thd, all);
8587
1/2
✓ Branch 0 taken 645 times.
✗ Branch 1 not taken.
 645 gtid_state->update_on_rollback(thd);
8588
2/4
✓ Branch 0 taken 645 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 645 times.
✗ Branch 3 not taken.
 645 thd_get_cache_mngr(thd)->reset();
8589
2/2
✓ Branch 0 taken 621 times.
✓ Branch 1 taken 24 times.
 645 if (thd->get_stmt_da()->is_ok())
8590
1/2
✓ Branch 0 taken 621 times.
✗ Branch 1 not taken.
 621 thd->get_stmt_da()->reset_diagnostics_area();
8591
1/2
✓ Branch 0 taken 645 times.
✗ Branch 1 not taken.
 645 my_error(ER_TRANSACTION_ROLLBACK_DURING_COMMIT, MYF(0));
8592 645 return RESULT_ABORTED;
8593 }
8594
8595
1/2
✓ Branch 0 taken 5924878 times.
✗ Branch 1 not taken.
 5925036 int rc = ordered_commit(thd, all, skip_commit);
8596
8597
2/2
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 5924796 times.
 5924878 if (rc) return RESULT_INCONSISTENT;
8598
8599
4/6
✓ Branch 0 taken 5924849 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 5924846 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 3 times.
 5924796 DBUG_EXECUTE_IF("ensure_binlog_cache_is_reset", {
8600 /* Assert that binlog cache is reset at commit time. */
8601 assert(binlog_cache_is_reset);
8602 binlog_cache_is_reset = false;
8603 };);
8604
8605 /*
8606 Mark the flag m_is_binlogged to true only after we are done
8607 with checking all the error cases.
8608 */
8609
3/4
✓ Branch 0 taken 5924806 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 527 times.
✓ Branch 3 taken 5924279 times.
 5924849 if (is_loggable_xa_prepare(thd)) {
8610 527 thd->get_transaction()->xid_state()->set_binlogged();
8611 /*
8612 Inform hook listeners that a XA PREPARE did commit, that
8613 is, did log a transaction to the binary log.
8614 */
8615
4/6
✓ Branch 0 taken 527 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84 times.
✓ Branch 3 taken 443 times.
✓ Branch 4 taken 85 times.
✗ Branch 5 not taken.
 527 (void)RUN_HOOK(transaction, after_commit, (thd, all));
8616 }
8617
2/2
✓ Branch 0 taken 8124318 times.
✓ Branch 1 taken 76 times.
 14049201 } else if (!skip_commit) {
8618 /*
8619 We only set engine binlog position in ordered_commit path flush phase
8620 and not all transactions go through them (such as table copy in DDL).
8621 So in cases where a DDL statement implicitly commits earlier transaction
8622 and starting a new one, the new transaction could be "leaking" the
8623 engine binlog pos. In order to avoid that and accidentally overwrite
8624 binlog position with previous location, we reset it here.
8625 */
8626
1/2
✓ Branch 0 taken 8124449 times.
✗ Branch 1 not taken.
 8124318 thd->set_trans_pos(nullptr, 0);
8627
3/4
✓ Branch 0 taken 8124395 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 8124381 times.
 8124449 if (trx_coordinator::commit_in_engines(thd, all))
8628 14 return RESULT_INCONSISTENT;
8629 }
8630
8631 14049264 return RESULT_SUCCESS;
8632 39473922 }
8633
8634 /**
8635 Flush caches for session.
8636
8637 @note @c set_trans_pos is called with a pointer to the file name
8638 that the binary log currently use and a rotation will change the
8639 contents of the variable.
8640
8641 The position is used when calling the after_flush, after_commit,
8642 and after_rollback hooks, but these have been placed so that they
8643 occur before a rotation is executed.
8644
8645 It is the responsibility of any plugin that use this position to
8646 copy it if they need it after the hook has returned.
8647
8648 The current "global" transaction_counter is stepped and its new value
8649 is assigned to the transaction.
8650 */
8651 5926417 std::pair<int, my_off_t> MYSQL_BIN_LOG::flush_thread_caches(THD *thd) {
8652
1/2
✓ Branch 0 taken 5926417 times.
✗ Branch 1 not taken.
 5926417 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd);
8653 5926417 my_off_t bytes = 0;
8654 5926417 bool wrote_xid = false;
8655
1/2
✓ Branch 0 taken 5926414 times.
✗ Branch 1 not taken.
 5926417 int error = cache_mngr->flush(thd, &bytes, &wrote_xid);
8656
3/4
✓ Branch 0 taken 5926410 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 5926410 times.
✗ Branch 3 not taken.
 5926414 if (!error && bytes > 0) {
8657 /*
8658 Note that set_trans_pos does not copy the file name. See
8659 this function documentation for more info.
8660 */
8661
1/2
✓ Branch 0 taken 5926410 times.
✗ Branch 1 not taken.
 5926410 thd->set_trans_pos(log_file_name, m_binlog_file->position());
8662
3/4
✓ Branch 0 taken 5385682 times.
✓ Branch 1 taken 540728 times.
✓ Branch 2 taken 5385682 times.
✗ Branch 3 not taken.
 5926410 if (wrote_xid) inc_prep_xids(thd);
8663 }
8664
5/8
✓ Branch 0 taken 5926414 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5926414 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 100 times.
✓ Branch 5 taken 5926314 times.
✓ Branch 6 taken 100 times.
✗ Branch 7 not taken.
 5926414 DBUG_PRINT("debug", ("bytes: %llu", bytes));
8665
1/2
✓ Branch 0 taken 5926414 times.
✗ Branch 1 not taken.
 11852828 return std::make_pair(error, bytes);
8666 }
8667
8668 5925933 void MYSQL_BIN_LOG::init_thd_variables(THD *thd, bool all, bool skip_commit) {
8669 /*
8670 These values are used while committing a transaction, so clear
8671 everything.
8672
8673 Notes:
8674
8675 - It would be good if we could keep transaction coordinator
8676 log-specific data out of the THD structure, but that is not the
8677 case right now.
8678
8679 - Everything in the transaction structure is reset when calling
8680 ha_commit_low since that calls Transaction_ctx::cleanup.
8681 */
8682 5925933 thd->tx_commit_pending = true;
8683 5925933 thd->commit_error = THD::CE_NONE;
8684 5925933 thd->next_to_commit = nullptr;
8685 5925933 thd->durability_property = HA_IGNORE_DURABILITY;
8686 5925933 thd->get_transaction()->m_flags.real_commit = all;
8687 5926190 thd->get_transaction()->m_flags.xid_written = false;
8688 5926393 thd->get_transaction()->m_flags.commit_low = !skip_commit;
8689 5926397 thd->get_transaction()->m_flags.run_hooks = !skip_commit;
8690 #ifndef NDEBUG
8691 /*
8692 The group commit Leader may have to wait for follower whose transaction
8693 is not ready to be preempted. Initially the status is pessimistic.
8694 Preemption guarding logics is necessary only when !NDEBUG is set.
8695 It won't be required for the dbug-off case as long as the follower won't
8696 execute any thread-specific write access code in this method, which is
8697 the case as of current.
8698 */
8699 5926313 thd->get_transaction()->m_flags.ready_preempt = false;
8700 #endif
8701 5926382 }
8702
8703 5823420 THD *MYSQL_BIN_LOG::fetch_and_process_flush_stage_queue(
8704 const bool check_and_skip_flush_logs) {
8705 /*
8706 Fetch the entire flush queue and empty it, so that the next batch
8707 has a leader. We must do this before invoking ha_flush_logs(...)
8708 for guaranteeing to flush prepared records of transactions before
8709 flushing them to binary log, which is required by crash recovery.
8710 */
8711 5823420 Commit_stage_manager::get_instance().lock_queue(
8712 Commit_stage_manager::BINLOG_FLUSH_STAGE);
8713
8714 THD *first_seen =
8715 5823420 Commit_stage_manager::get_instance().fetch_queue_skip_acquire_lock(
8716 Commit_stage_manager::BINLOG_FLUSH_STAGE);
8717
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5823420 times.
 5823420 assert(first_seen != nullptr);
8718
8719 THD *commit_order_thd =
8720 5823420 Commit_stage_manager::get_instance().fetch_queue_skip_acquire_lock(
8721 Commit_stage_manager::COMMIT_ORDER_FLUSH_STAGE);
8722
8723 5823420 Commit_stage_manager::get_instance().unlock_queue(
8724 Commit_stage_manager::BINLOG_FLUSH_STAGE);
8725
8726
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5823419 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 5823420 if (!check_and_skip_flush_logs ||
8727
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 (check_and_skip_flush_logs && commit_order_thd != nullptr)) {
8728 /*
8729 We flush prepared records of transactions to the log of storage
8730 engine (for example, InnoDB redo log) in a group right before
8731 flushing them to binary log.
8732 */
8733 5823419 ha_flush_logs(true);
8734 }
8735
8736 /*
8737 The transactions are flushed to the disk and so threads
8738 executing slave preserve commit order can be unblocked.
8739 */
8740 5823413 Commit_stage_manager::get_instance()
8741 5823413 .process_final_stage_for_ordered_commit_group(commit_order_thd);
8742 5823413 return first_seen;
8743 }
8744
8745 5823419 int MYSQL_BIN_LOG::process_flush_stage_queue(my_off_t *total_bytes_var,
8746 bool *rotate_var,
8747 THD **out_queue_var) {
8748
1/2
✓ Branch 0 taken 5823419 times.
✗ Branch 1 not taken.
 5823419 DBUG_TRACE;
8749 #ifndef NDEBUG
8750 // number of flushes per group.
8751 5823419 int no_flushes = 0;
8752 #endif
8753
3/6
✓ Branch 0 taken 5823419 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5823419 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5823419 times.
✗ Branch 5 not taken.
 5823419 assert(total_bytes_var && rotate_var && out_queue_var);
8754 5823419 my_off_t total_bytes = 0;
8755 5823419 int flush_error = 1;
8756 5823419 mysql_mutex_assert_owner(&LOCK_log);
8757
8758
1/2
✓ Branch 0 taken 5823412 times.
✗ Branch 1 not taken.
 5823419 THD *first_seen = fetch_and_process_flush_stage_queue();
8759
4/6
✓ Branch 0 taken 5823412 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 5823408 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
 5823412 DBUG_EXECUTE_IF("crash_after_flush_engine_log", DBUG_SUICIDE(););
8760
2/4
✓ Branch 0 taken 5823408 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5823408 times.
✗ Branch 3 not taken.
 5823408 CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_write_binlog");
8761
1/2
✓ Branch 0 taken 5823408 times.
✗ Branch 1 not taken.
 5823408 assign_automatic_gtids_to_flush_group(first_seen);
8762 /* Flush thread caches to binary log. */
8763
2/2
✓ Branch 0 taken 5926417 times.
✓ Branch 1 taken 5823405 times.
 11749822 for (THD *head = first_seen; head; head = head->next_to_commit) {
8764
2/4
✓ Branch 0 taken 5926417 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5926417 times.
✗ Branch 3 not taken.
 5926417 Thd_backup_and_restore switch_thd(current_thd, head);
8765
1/2
✓ Branch 0 taken 5926414 times.
✗ Branch 1 not taken.
 5926417 std::pair<int, my_off_t> result = flush_thread_caches(head);
8766 5926414 total_bytes += result.second;
8767
2/2
✓ Branch 0 taken 5823405 times.
✓ Branch 1 taken 103009 times.
 5926414 if (flush_error == 1) flush_error = result.first;
8768 #ifndef NDEBUG
8769 5926414 no_flushes++;
8770 #endif
8771 5926414 }
8772
8773 5823405 *out_queue_var = first_seen;
8774 5823405 *total_bytes_var = total_bytes;
8775
4/4
✓ Branch 0 taken 5823401 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 20098 times.
✓ Branch 3 taken 5803307 times.
 11646806 if (total_bytes > 0 &&
8776
2/2
✓ Branch 0 taken 5803304 times.
✓ Branch 1 taken 20097 times.
 5823401 (m_binlog_file->get_real_file_size() >= (my_off_t)max_size ||
8777
3/4
✓ Branch 0 taken 5803304 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 5803303 times.
 5803304 DBUG_EVALUATE_IF("simulate_max_binlog_size", true, false)))
8778 20098 *rotate_var = true;
8779 #ifndef NDEBUG
8780
5/8
✓ Branch 0 taken 5823405 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5823405 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 103 times.
✓ Branch 5 taken 5823302 times.
✓ Branch 6 taken 103 times.
✗ Branch 7 not taken.
 5823405 DBUG_PRINT("info", ("no_flushes:= %d", no_flushes));
8781 5823405 no_flushes = 0;
8782 #endif
8783 5823405 return flush_error;
8784 5823405 }
8785
8786 /**
8787 Commit a sequence of sessions.
8788
8789 This function commit an entire queue of sessions starting with the
8790 session in @c first. If there were an error in the flushing part of
8791 the ordered commit, the error code is passed in and all the threads
8792 are marked accordingly (but not committed).
8793
8794 It will also add the GTIDs of the transactions to gtid_executed.
8795
8796 @see MYSQL_BIN_LOG::ordered_commit
8797
8798 @param thd The "master" thread
8799 @param first First thread in the queue of threads to commit
8800 */
8801
8802 5772700 void MYSQL_BIN_LOG::process_commit_stage_queue(THD *thd, THD *first) {
8803 5772700 mysql_mutex_assert_owner(&LOCK_commit);
8804 #ifndef NDEBUG
8805 5772700 thd->get_transaction()->m_flags.ready_preempt =
8806 true; // formality by the leader
8807 #endif
8808
2/2
✓ Branch 0 taken 5925658 times.
✓ Branch 1 taken 5772699 times.
 11698357 for (THD *head = first; head; head = head->next_to_commit) {
8809
6/10
✓ Branch 0 taken 5925658 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5925658 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 98 times.
✓ Branch 5 taken 5925560 times.
✓ Branch 6 taken 98 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 98 times.
✗ Branch 9 not taken.
 5925658 DBUG_PRINT("debug", ("Thread ID: %u, commit_error: %d, commit_pending: %s",
8810 head->thread_id(), head->commit_error,
8811 YESNO(head->tx_commit_pending)));
8812
2/8
✓ Branch 0 taken 5925658 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5925658 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 5925658 DBUG_EXECUTE_IF(
8813 "block_leader_after_delete",
8814 if (thd != head) { DBUG_SET("+d,after_delete_wait"); };);
8815 /*
8816 If flushing failed, set commit_error for the session, skip the
8817 transaction and proceed with the next transaction instead. This
8818 will mark all threads as failed, since the flush failed.
8819
8820 If flush succeeded, attach to the session and commit it in the
8821 engines.
8822 */
8823 #ifndef NDEBUG
8824
2/4
✓ Branch 0 taken 5925658 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5925658 times.
✗ Branch 3 not taken.
 5925658 Commit_stage_manager::get_instance().clear_preempt_status(head);
8825 #endif
8826
2/2
✓ Branch 0 taken 5925657 times.
✓ Branch 1 taken 1 times.
 5925658 if (head->get_transaction()->sequence_number != SEQ_UNINIT) {
8827
1/2
✓ Branch 0 taken 5925657 times.
✗ Branch 1 not taken.
 5925657 mysql_mutex_lock(&LOCK_replica_trans_dep_tracker);
8828
1/2
✓ Branch 0 taken 5925657 times.
✗ Branch 1 not taken.
 5925657 m_dependency_tracker.update_max_committed(head);
8829
1/2
✓ Branch 0 taken 5925657 times.
✗ Branch 1 not taken.
 5925657 mysql_mutex_unlock(&LOCK_replica_trans_dep_tracker);
8830 }
8831 /*
8832 Flush/Sync error should be ignored and continue
8833 to commit phase. And thd->commit_error cannot be
8834 COMMIT_ERROR at this moment.
8835 */
8836
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5925658 times.
 5925658 assert(head->commit_error != THD::CE_COMMIT_ERROR);
8837
1/2
✓ Branch 0 taken 5925658 times.
✗ Branch 1 not taken.
 5925658 Thd_backup_and_restore switch_thd(thd, head);
8838 5925658 bool all = head->get_transaction()->m_flags.real_commit;
8839
3/4
✓ Branch 0 taken 5923835 times.
✓ Branch 1 taken 1823 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5923835 times.
 5925658 assert(!head->get_transaction()->m_flags.commit_low ||
8840 head->get_transaction()->m_flags.ready_preempt);
8841
1/2
✓ Branch 0 taken 5925657 times.
✗ Branch 1 not taken.
 5925658 ::finish_transaction_in_engines(head, all, false);
8842
6/10
✓ Branch 0 taken 5925657 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5925657 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 98 times.
✓ Branch 5 taken 5925559 times.
✓ Branch 6 taken 98 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 98 times.
✗ Branch 9 not taken.
 5925657 DBUG_PRINT("debug", ("commit_error: %d, commit_pending: %s",
8843 head->commit_error, YESNO(head->tx_commit_pending)));
8844 5925657 }
8845
8846
2/2
✓ Branch 0 taken 5770049 times.
✓ Branch 1 taken 2650 times.
 5772699 DEBUG_SYNC(thd, "process_commit_stage_queue_before_handle_gtid");
8847 /*
8848 Handle the GTID of the threads.
8849 gtid_executed table is kept updated even though transactions fail to be
8850 logged. That's required by slave auto positioning.
8851 */
8852 5772699 gtid_state->update_commit_group(first);
8853
8854
2/2
✓ Branch 0 taken 5925645 times.
✓ Branch 1 taken 5772687 times.
 11698332 for (THD *head = first; head; head = head->next_to_commit) {
8855
1/2
✓ Branch 0 taken 5925645 times.
✗ Branch 1 not taken.
 5925645 Thd_backup_and_restore switch_thd(thd, head);
8856 5925645 auto all = head->get_transaction()->m_flags.real_commit;
8857 // Mark transaction as prepared in TC, if applicable
8858
1/2
✓ Branch 0 taken 5925645 times.
✗ Branch 1 not taken.
 5925645 trx_coordinator::set_prepared_in_tc_in_engines(head, all);
8859 /*
8860 Decrement the prepared XID counter after storage engine commit.
8861 We also need decrement the prepared XID when encountering a
8862 flush error or session attach error for avoiding 3-way deadlock
8863 among user thread, rotate thread and dump thread.
8864 */
8865
3/4
✓ Branch 0 taken 5384918 times.
✓ Branch 1 taken 540727 times.
✓ Branch 2 taken 5384918 times.
✗ Branch 3 not taken.
 5925645 if (head->get_transaction()->m_flags.xid_written) dec_prep_xids(head);
8866 5925645 }
8867 5772687 }
8868
8869 /**
8870 Process after commit for a sequence of sessions.
8871
8872 @param thd The "master" thread
8873 @param first First thread in the queue of threads to commit
8874 */
8875
8876 5772685 void MYSQL_BIN_LOG::process_after_commit_stage_queue(THD *thd, THD *first) {
8877
2/2
✓ Branch 0 taken 5925644 times.
✓ Branch 1 taken 5772682 times.
 11698326 for (THD *head = first; head; head = head->next_to_commit) {
8878
4/4
✓ Branch 0 taken 5923826 times.
✓ Branch 1 taken 1818 times.
✓ Branch 2 taken 5923826 times.
✓ Branch 3 taken 1818 times.
 11849470 if (head->get_transaction()->m_flags.run_hooks &&
8879
1/2
✓ Branch 0 taken 5923826 times.
✗ Branch 1 not taken.
 5923826 head->commit_error != THD::CE_COMMIT_ERROR) {
8880 /*
8881 TODO: This hook here should probably move outside/below this
8882 if and be the only after_commit invocation left in the
8883 code.
8884 */
8885
1/2
✓ Branch 0 taken 5923827 times.
✗ Branch 1 not taken.
 5923826 Thd_backup_and_restore switch_thd(thd, head);
8886 5923827 bool all = head->get_transaction()->m_flags.real_commit;
8887
4/6
✓ Branch 0 taken 5923826 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 103057 times.
✓ Branch 3 taken 5820769 times.
✓ Branch 4 taken 103055 times.
✗ Branch 5 not taken.
 5923827 (void)RUN_HOOK(transaction, after_commit, (head, all));
8888 /*
8889 When after_commit finished for the transaction, clear the run_hooks
8890 flag. This allow other parts of the system to check if after_commit was
8891 called.
8892 */
8893 5923824 head->get_transaction()->m_flags.run_hooks = false;
8894 5923826 }
8895 }
8896 5772682 }
8897
8898 #ifndef NDEBUG
8899 /** Names for the stages. */
8900 static const char *g_stage_name[] = {
8901 "FLUSH",
8902 "SYNC",
8903 "COMMIT",
8904 };
8905 #endif
8906
8907 17553496 bool MYSQL_BIN_LOG::change_stage(THD *thd [[maybe_unused]],
8908 Commit_stage_manager::StageID stage,
8909 THD *queue, mysql_mutex_t *leave_mutex,
8910 mysql_mutex_t *enter_mutex) {
8911
1/2
✓ Branch 0 taken 17553968 times.
✗ Branch 1 not taken.
 17553496 DBUG_TRACE;
8912
5/8
✓ Branch 0 taken 17553739 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17553828 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 299 times.
✓ Branch 5 taken 17553529 times.
✓ Branch 6 taken 299 times.
✗ Branch 7 not taken.
 17553968 DBUG_PRINT("enter", ("thd: 0x%llx, stage: %s, queue: 0x%llx", (ulonglong)thd,
8913 g_stage_name[stage], (ulonglong)queue));
8914
2/4
✓ Branch 0 taken 17553846 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17553850 times.
✗ Branch 3 not taken.
 17553828 assert(0 <= stage && stage < Commit_stage_manager::STAGE_COUNTER);
8915
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17553850 times.
 17553850 assert(enter_mutex);
8916
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17553850 times.
 17553850 assert(queue);
8917 /*
8918 enroll_for will release the leave_mutex once the sessions are
8919 queued.
8920 */
8921
4/6
✓ Branch 0 taken 17553418 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17553530 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 152960 times.
✓ Branch 5 taken 17400570 times.
 17553850 if (!Commit_stage_manager::get_instance().enroll_for(
8922 stage, queue, leave_mutex, enter_mutex)) {
8923
2/4
✓ Branch 0 taken 152959 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 152957 times.
 152960 assert(!thd_get_cache_mngr(thd)->dbug_any_finalized());
8924 152957 return true;
8925 }
8926
8927 17400570 return false;
8928 17553527 }
8929
8930 /**
8931 Flush the I/O cache to file.
8932
8933 Flush the binary log to the binlog file if any byte where written
8934 and signal that the binary log file has been updated if the flush
8935 succeeds.
8936 */
8937
8938 5823401 int MYSQL_BIN_LOG::flush_cache_to_file(my_off_t *end_pos_var) {
8939
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5823399 times.
 5823401 if (m_binlog_file->flush()) {
8940 2 THD *thd = current_thd;
8941 2 thd->commit_error = THD::CE_FLUSH_ERROR;
8942 2 return ER_ERROR_ON_WRITE;
8943 }
8944 5823399 *end_pos_var = m_binlog_file->position();
8945 5823399 return 0;
8946 }
8947
8948 /**
8949 Call fsync() to sync the file to disk.
8950 */
8951 7580711 std::pair<bool, bool> MYSQL_BIN_LOG::sync_binlog_file(bool force) {
8952 7580711 bool synced = false;
8953 7580711 unsigned int sync_period = get_sync_period();
8954
8/8
✓ Branch 0 taken 7572144 times.
✓ Branch 1 taken 8571 times.
✓ Branch 2 taken 7496988 times.
✓ Branch 3 taken 75156 times.
✓ Branch 4 taken 5728598 times.
✓ Branch 5 taken 1768390 times.
✓ Branch 6 taken 5737169 times.
✓ Branch 7 taken 1843546 times.
 7580715 if (force || (sync_period && ++sync_counter >= sync_period)) {
8955 5737169 sync_counter = 0;
8956
8957 /*
8958 There is a chance that binlog file could be closed by 'RESET MASTER' or
8959 or 'FLUSH LOGS' just after the leader releases LOCK_log and before it
8960 acquires LOCK_sync log. So it should check if m_binlog_file is opened.
8961 */
8962
9/12
✓ Branch 0 taken 5737169 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5737165 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 5737164 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 5737164 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 5737164 times.
✓ Branch 10 taken 4 times.
✓ Branch 11 taken 5737165 times.
 5737169 if (DBUG_EVALUATE_IF("simulate_error_during_sync_binlog_file", 1,
8963 m_binlog_file->is_open() && m_binlog_file->sync())) {
8964
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 THD *thd = current_thd;
8965 4 thd->commit_error = THD::CE_SYNC_ERROR;
8966
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 return std::make_pair(true, synced);
8967 }
8968 5737165 synced = true;
8969 }
8970
1/2
✓ Branch 0 taken 7580712 times.
✗ Branch 1 not taken.
 7580711 return std::make_pair(false, synced);
8971 }
8972
8973 /**
8974 Helper function executed when leaving @c ordered_commit.
8975
8976 This function contain the necessary code for fetching the error
8977 code, doing post-commit checks, and wrapping up the commit if
8978 necessary.
8979
8980 It is typically called when enter_stage indicates that the thread
8981 should bail out, and also when the ultimate leader thread finishes
8982 executing @c ordered_commit.
8983
8984 It is typically used in this manner:
8985 @code
8986 if (enter_stage(thd, Thread_queue::BINLOG_FLUSH_STAGE, thd, &LOCK_log))
8987 return finish_commit(thd);
8988 @endcode
8989
8990 @return Error code if the session commit failed, or zero on
8991 success.
8992 */
8993 5926245 int MYSQL_BIN_LOG::finish_commit(THD *thd) {
8994
1/2
✓ Branch 0 taken 5926264 times.
✗ Branch 1 not taken.
 5926245 DBUG_TRACE;
8995
3/4
✓ Branch 0 taken 5923602 times.
✓ Branch 1 taken 2662 times.
✓ Branch 2 taken 5923613 times.
✗ Branch 3 not taken.
 5926264 DEBUG_SYNC(thd, "reached_finish_commit");
8996 /*
8997 In some unlikely situations, it can happen that binary
8998 log is closed before the thread flushes it's cache.
8999 In that case, clear the caches before doing commit.
9000 */
9001
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 5926237 times.
 5926275 if (unlikely(!is_open())) {
9002
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd);
9003
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
 15 if (cache_mngr) cache_mngr->reset();
9004 }
9005
9006
2/2
✓ Branch 0 taken 624 times.
✓ Branch 1 taken 5925611 times.
 5926252 if (thd->get_transaction()->sequence_number != SEQ_UNINIT) {
9007
1/2
✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
 624 mysql_mutex_lock(&LOCK_replica_trans_dep_tracker);
9008
1/2
✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
 624 m_dependency_tracker.update_max_committed(thd);
9009
1/2
✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
 624 mysql_mutex_unlock(&LOCK_replica_trans_dep_tracker);
9010 }
9011
9012 5926235 auto all = thd->get_transaction()->m_flags.real_commit;
9013 5926235 auto committed_low = thd->get_transaction()->m_flags.commit_low;
9014
9015
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5926266 times.
 5926266 assert(thd->commit_error != THD::CE_COMMIT_ERROR);
9016
1/2
✓ Branch 0 taken 5926241 times.
✗ Branch 1 not taken.
 5926266 ::finish_transaction_in_engines(thd, all, false);
9017
9018 // If the ordered commit didn't updated the GTIDs for this thd yet
9019 // at process_commit_stage_queue (i.e. --binlog-order-commits=0)
9020 // the thd still has the ownership of a GTID and we must handle it.
9021
3/4
✓ Branch 0 taken 5926194 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1314 times.
✓ Branch 3 taken 5924880 times.
 5926241 if (!thd->owned_gtid_is_empty()) {
9022
1/2
✓ Branch 0 taken 1314 times.
✗ Branch 1 not taken.
 1314 if (thd->commit_error == THD::CE_NONE) {
9023
1/2
✓ Branch 0 taken 1314 times.
✗ Branch 1 not taken.
 1314 gtid_state->update_on_commit(thd);
9024 } else
9025 ✗ gtid_state->update_on_rollback(thd);
9026 }
9027
9028 // If not yet done, mark transaction as prepared in TC, if applicable and
9029 // unfence the rotation of the binary log
9030
2/2
✓ Branch 0 taken 624 times.
✓ Branch 1 taken 5925574 times.
 5926194 if (thd->get_transaction()->m_flags.xid_written) {
9031
1/2
✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
 624 trx_coordinator::set_prepared_in_tc_in_engines(thd, all);
9032
1/2
✓ Branch 0 taken 611 times.
✗ Branch 1 not taken.
 624 dec_prep_xids(thd);
9033 }
9034
9035 // If the transaction was committed successfully, run the after_commit
9036
5/6
✓ Branch 0 taken 1024 times.
✓ Branch 1 taken 5925161 times.
✓ Branch 2 taken 1024 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 624 times.
✓ Branch 5 taken 5925561 times.
 5927209 if (committed_low && (thd->commit_error != THD::CE_COMMIT_ERROR) &&
9037
2/2
✓ Branch 0 taken 624 times.
✓ Branch 1 taken 400 times.
 1024 thd->get_transaction()->m_flags.run_hooks) {
9038
4/6
✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 606 times.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
 624 (void)RUN_HOOK(transaction, after_commit, (thd, all));
9039 624 thd->get_transaction()->m_flags.run_hooks = false;
9040 }
9041
9042
2/10
✓ Branch 0 taken 5926175 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5926175 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 5926185 DBUG_EXECUTE_IF("leaving_finish_commit", {
9043 const char act[] = "now SIGNAL signal_leaving_finish_commit";
9044 assert(!debug_sync_set_action(current_thd, STRING_WITH_LEN(act)));
9045 };);
9046
9047
3/4
✓ Branch 0 taken 5916279 times.
✓ Branch 1 taken 9896 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5916281 times.
 5926175 assert(thd->commit_error || !thd->get_transaction()->m_flags.run_hooks);
9048
2/4
✓ Branch 0 taken 5926238 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5926232 times.
 5926177 assert(!thd_get_cache_mngr(thd)->dbug_any_finalized());
9049
5/8
✓ Branch 0 taken 5926177 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5926179 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 98 times.
✓ Branch 5 taken 5926081 times.
✓ Branch 6 taken 98 times.
✗ Branch 7 not taken.
 5926232 DBUG_PRINT("return", ("Thread ID: %u, commit_error: %d", thd->thread_id(),
9050 thd->commit_error));
9051 /*
9052 flush or sync errors are handled by the leader of the group
9053 (using binlog_error_action). Hence treat only COMMIT_ERRORs as errors.
9054 */
9055 5926225 return thd->commit_error == THD::CE_COMMIT_ERROR;
9056 5926179 }
9057
9058 /**
9059 Auxiliary function used in ordered_commit.
9060 */
9061 5773311 static inline int call_after_sync_hook(THD *queue_head) {
9062 5773311 const char *log_file = nullptr;
9063 5773311 my_off_t pos = 0;
9064
9065
3/4
✓ Branch 0 taken 5773311 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5747159 times.
✓ Branch 3 taken 26152 times.
 5773311 if (NO_HOOK(binlog_storage)) return 0;
9066
9067
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26152 times.
 26152 assert(queue_head != nullptr);
9068
2/2
✓ Branch 0 taken 63548 times.
✓ Branch 1 taken 26152 times.
 89700 for (THD *thd = queue_head; thd != nullptr; thd = thd->next_to_commit)
9069
1/2
✓ Branch 0 taken 63548 times.
✗ Branch 1 not taken.
 63548 if (likely(thd->commit_error == THD::CE_NONE))
9070
1/2
✓ Branch 0 taken 63548 times.
✗ Branch 1 not taken.
 63548 thd->get_trans_fixed_pos(&log_file, &pos);
9071
9072
6/8
✓ Branch 0 taken 26152 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26149 times.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 26149 times.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 26149 times.
 52301 if (DBUG_EVALUATE_IF("simulate_after_sync_hook_error", 1, 0) ||
9073
3/6
✓ Branch 0 taken 26149 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 26149 times.
✓ Branch 4 taken 26149 times.
✗ Branch 5 not taken.
 26149 RUN_HOOK(binlog_storage, after_sync, (queue_head, log_file, pos))) {
9074
8/16
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
 3 LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_RUN_AFTER_SYNC_HOOK);
9075 3 return ER_ERROR_ON_WRITE;
9076 }
9077 26149 return 0;
9078 }
9079
9080 /**
9081 Helper function to handle flush or sync stage errors.
9082 If binlog_error_action= ABORT_SERVER, server will be aborted
9083 after reporting the error to the client.
9084 If binlog_error_action= IGNORE_ERROR, binlog will be closed
9085 for the reset of the life time of the server. close() call is protected
9086 with LOCK_log to avoid any parallel operations on binary log.
9087
9088 @param thd Thread object that faced flush/sync error
9089 @param need_lock_log
9090 > Indicates true if LOCk_log is needed before closing
9091 binlog (happens when we are handling sync error)
9092 > Indicates false if LOCK_log is already acquired
9093 by the thread (happens when we are handling flush
9094 error)
9095 @param message Message stating the reason of the failure
9096 */
9097 14 void MYSQL_BIN_LOG::handle_binlog_flush_or_sync_error(THD *thd,
9098 bool need_lock_log,
9099 const char *message) {
9100 14 char errmsg[MYSQL_ERRMSG_SIZE] = {0};
9101
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 2 times.
 14 if (message == nullptr)
9102 24 sprintf(
9103 errmsg,
9104 "An error occurred during %s stage of the commit. "
9105 "'binlog_error_action' is set to '%s'.",
9106
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 7 times.
 12 thd->commit_error == THD::CE_FLUSH_ERROR ? "flush" : "sync",
9107
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 binlog_error_action == ABORT_SERVER ? "ABORT_SERVER" : "IGNORE_ERROR");
9108 else
9109 2 strncpy(errmsg, message, MYSQL_ERRMSG_SIZE - 1);
9110
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
 14 if (binlog_error_action == ABORT_SERVER) {
9111 char err_buff[MYSQL_ERRMSG_SIZE + 25];
9112 ✗ sprintf(err_buff, "%s Server is being stopped.", errmsg);
9113 ✗ exec_binlog_error_action_abort(err_buff);
9114 } else {
9115
2/4
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
 14 DEBUG_SYNC(thd, "before_binlog_closed_due_to_error");
9116
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 6 times.
 14 if (need_lock_log)
9117
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 mysql_mutex_lock(&LOCK_log);
9118 else
9119 6 mysql_mutex_assert_owner(&LOCK_log);
9120 /*
9121 It can happen that other group leader encountered
9122 error and already closed the binary log. So print
9123 error only if it is in open state. But we should
9124 call close() always just in case if the previous
9125 close did not close index file.
9126 */
9127
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 1 times.
 14 if (is_open()) {
9128
8/16
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 13 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 13 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 13 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 13 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 13 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 13 times.
✗ Branch 15 not taken.
 13 LogErr(ERROR_LEVEL, ER_TURNING_LOGGING_OFF_FOR_THE_DURATION, errmsg);
9129 }
9130
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT, false /*need_lock_log=false*/,
9131 true /*need_lock_index=true*/);
9132 /*
9133 If there is a write error (flush/sync stage) and if
9134 binlog_error_action=IGNORE_ERROR, clear the error
9135 and allow the commit to happen in storage engine.
9136 */
9137
5/6
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 12 times.
 17 if (check_write_error(thd) &&
9138
3/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
 3 DBUG_EVALUATE_IF("simulate_cache_creation_failure", false, true)) {
9139 /* we have DA_ERROR */
9140
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 thd->clear_error(); /* sets thd->get_stmt_da()->status() to DA_EMPTY */
9141 /* For SQLCOM_COMMIT, ROLLBACK, ROLLBACK TO SAVEPOINT, there is already
9142 my_ok() in mysql_execute_command. Doing double my_ok() is not allowed. So
9143 we avoid that here */
9144
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (thd_sql_command(thd) != SQLCOM_COMMIT &&
9145
6/8
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 1 times.
 3 thd_sql_command(thd) != SQLCOM_ROLLBACK &&
9146
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 thd_sql_command(thd) != SQLCOM_ROLLBACK_TO_SAVEPOINT) {
9147
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 my_ok(thd); /* sets thd->get_stmt_da()->status() to DA_OK */
9148 }
9149 }
9150
9151
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
 14 if (need_lock_log) mysql_mutex_unlock(&LOCK_log);
9152
2/4
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
 14 DEBUG_SYNC(thd, "after_binlog_closed_due_to_error");
9153 }
9154 14 }
9155
9156 5925928 int MYSQL_BIN_LOG::ordered_commit(THD *thd, bool all, bool skip_commit) {
9157
1/2
✓ Branch 0 taken 5926364 times.
✗ Branch 1 not taken.
 5925928 DBUG_TRACE;
9158 5926364 int flush_error = 0, sync_error = 0;
9159 5926364 my_off_t total_bytes = 0;
9160 5926364 bool do_rotate = false;
9161
9162
4/6
✓ Branch 0 taken 5926167 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.
✓ Branch 3 taken 5926077 times.
✓ Branch 4 taken 90 times.
✗ Branch 5 not taken.
 5926364 DBUG_EXECUTE_IF("crash_commit_before_log", DBUG_SUICIDE(););
9163
1/2
✓ Branch 0 taken 5926393 times.
✗ Branch 1 not taken.
 5926077 init_thd_variables(thd, all, skip_commit);
9164
6/10
✓ Branch 0 taken 5926050 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5926126 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 103 times.
✓ Branch 5 taken 5926023 times.
✓ Branch 6 taken 103 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 103 times.
✗ Branch 9 not taken.
 5926393 DBUG_PRINT("enter", ("commit_pending: %s, commit_error: %d, thread_id: %u",
9165 YESNO(thd->tx_commit_pending), thd->commit_error,
9166 thd->thread_id()));
9167
9168
3/4
✓ Branch 0 taken 5923259 times.
✓ Branch 1 taken 2633 times.
✓ Branch 2 taken 5923625 times.
✗ Branch 3 not taken.
 5926126 DEBUG_SYNC(thd, "bgc_before_flush_stage");
9169
9170 /*
9171 Stage #0: ensure slave threads commit order as they appear in the slave's
9172 relay log for transactions flushing to binary log.
9173
9174 This will make thread wait until its turn to commit.
9175 Commit_order_manager maintains it own queue and its own order for the
9176 commit. So Stage#0 doesn't maintain separate StageID.
9177 */
9178
1/2
✓ Branch 0 taken 5925950 times.
✗ Branch 1 not taken.
 5926258 if (Commit_order_manager::wait_for_its_turn_before_flush_stage(thd) ||
9179
7/8
✓ Branch 0 taken 5907773 times.
✓ Branch 1 taken 18177 times.
✓ Branch 2 taken 5907919 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 197751 times.
✓ Branch 5 taken 5710168 times.
✓ Branch 6 taken 5728499 times.
✓ Branch 7 taken 197615 times.
 6123719 ending_trans(thd, all) ||
9180
2/4
✓ Branch 0 taken 197769 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 197769 times.
 197751 Commit_order_manager::get_rollback_status(thd)) {
9181
3/4
✓ Branch 0 taken 5728491 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 71 times.
✓ Branch 3 taken 5728420 times.
 5728499 if (Commit_order_manager::wait(thd)) {
9182 71 return thd->commit_error;
9183 }
9184 }
9185
9186 /*
9187 Stage #1: flushing transactions to binary log
9188
9189 While flushing, we allow new threads to enter and will process
9190 them in due time. Once the queue was empty, we cannot reap
9191 anything more since it is possible that a thread entered and
9192 appointed itself leader for the flush phase.
9193 */
9194
9195
3/4
✓ Branch 0 taken 5926410 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 103007 times.
✓ Branch 3 taken 5823403 times.
 5926035 if (change_stage(thd, Commit_stage_manager::BINLOG_FLUSH_STAGE, thd, nullptr,
9196 &LOCK_log)) {
9197
3/8
✓ Branch 0 taken 103006 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 103006 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 103006 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 103007 DBUG_PRINT("return", ("Thread ID: %u, commit_error: %d", thd->thread_id(),
9198 thd->commit_error));
9199
1/2
✓ Branch 0 taken 102985 times.
✗ Branch 1 not taken.
 103006 return finish_commit(thd);
9200 }
9201
9202 5823403 THD *wait_queue = nullptr, *final_queue = nullptr;
9203 5823403 mysql_mutex_t *leave_mutex_before_commit_stage = nullptr;
9204 5823403 my_off_t flush_end_pos = 0;
9205 bool update_binlog_end_pos_after_sync;
9206
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5823419 times.
 5823403 if (unlikely(!is_open())) {
9207
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 final_queue = fetch_and_process_flush_stage_queue(true);
9208 1 leave_mutex_before_commit_stage = &LOCK_log;
9209 /*
9210 binary log is closed, flush stage and sync stage should be
9211 ignored. Binlog cache should be cleared, but instead of doing
9212 it here, do that work in 'finish_commit' function so that
9213 leader and followers thread caches will be cleared.
9214 */
9215 1 goto commit_stage;
9216 }
9217
3/4
✓ Branch 0 taken 5820769 times.
✓ Branch 1 taken 2650 times.
✓ Branch 2 taken 5820769 times.
✗ Branch 3 not taken.
 5823419 DEBUG_SYNC(thd, "waiting_in_the_middle_of_flush_stage");
9218 flush_error =
9219
1/2
✓ Branch 0 taken 5823405 times.
✗ Branch 1 not taken.
 5823419 process_flush_stage_queue(&total_bytes, &do_rotate, &wait_queue);
9220
9221
3/4
✓ Branch 0 taken 5823401 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 5823401 times.
✗ Branch 3 not taken.
 5823405 if (flush_error == 0 && total_bytes > 0)
9222
1/2
✓ Branch 0 taken 5823401 times.
✗ Branch 1 not taken.
 5823401 flush_error = flush_cache_to_file(&flush_end_pos);
9223
4/6
✓ Branch 0 taken 5823405 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 5823401 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
 5823405 DBUG_EXECUTE_IF("crash_after_flush_binlog", DBUG_SUICIDE(););
9224
9225 5823401 update_binlog_end_pos_after_sync = (get_sync_period() == 1);
9226
9227 /*
9228 If the flush finished successfully, we can call the after_flush
9229 hook. Being invoked here, we have the guarantee that the hook is
9230 executed before the before/after_send_hooks on the dump thread
9231 preventing race conditions among these plug-ins.
9232 */
9233
2/2
✓ Branch 0 taken 5823395 times.
✓ Branch 1 taken 6 times.
 5823401 if (flush_error == 0) {
9234
1/2
✓ Branch 0 taken 5823395 times.
✗ Branch 1 not taken.
 5823395 const char *file_name_ptr = log_file_name + dirname_length(log_file_name);
9235
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5823395 times.
 5823395 assert(flush_end_pos != 0);
9236
5/8
✓ Branch 0 taken 5823395 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5785360 times.
✓ Branch 3 taken 38035 times.
✓ Branch 4 taken 38035 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 5823395 times.
 5823395 if (RUN_HOOK(binlog_storage, after_flush,
9237 (thd, file_name_ptr, flush_end_pos))) {
9238 ✗ LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_RUN_AFTER_FLUSH_HOOK);
9239 ✗ flush_error = ER_ERROR_ON_WRITE;
9240 }
9241
9242
3/4
✓ Branch 0 taken 77013 times.
✓ Branch 1 taken 5746382 times.
✓ Branch 2 taken 77013 times.
✗ Branch 3 not taken.
 5823395 if (!update_binlog_end_pos_after_sync) update_binlog_end_pos();
9243
9244
4/6
✓ Branch 0 taken 5823395 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 129 times.
✓ Branch 3 taken 5823266 times.
✓ Branch 4 taken 129 times.
✗ Branch 5 not taken.
 5823395 DBUG_EXECUTE_IF("crash_commit_after_log", DBUG_SUICIDE(););
9245 }
9246
9247
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 5823266 times.
 5823272 if (flush_error) {
9248 /*
9249 Handle flush error (if any) after leader finishes it's flush stage.
9250 */
9251
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 handle_binlog_flush_or_sync_error(
9252 thd, false /* need_lock_log */,
9253
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
 6 (thd->commit_error == THD::CE_FLUSH_GNO_EXHAUSTED_ERROR)
9254
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 ? ER_THD(thd, ER_GNO_EXHAUSTED)
9255 : nullptr);
9256 }
9257
9258
1/2
✓ Branch 0 taken 5823272 times.
✗ Branch 1 not taken.
 5823272 publish_coordinates_for_global_status();
9259
9260
3/4
✓ Branch 0 taken 5820622 times.
✓ Branch 1 taken 2650 times.
✓ Branch 2 taken 5820622 times.
✗ Branch 3 not taken.
 5823272 DEBUG_SYNC(thd, "bgc_after_flush_stage_before_sync_stage");
9261
9262 /*
9263 Stage #2: Syncing binary log file to disk
9264 */
9265
9266
3/4
✓ Branch 0 taken 5823270 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18175 times.
✓ Branch 3 taken 5805095 times.
 5823272 if (change_stage(thd, Commit_stage_manager::SYNC_STAGE, wait_queue, &LOCK_log,
9267 &LOCK_sync)) {
9268
3/8
✓ Branch 0 taken 18175 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18175 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 18175 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 18175 DBUG_PRINT("return", ("Thread ID: %u, commit_error: %d", thd->thread_id(),
9269 thd->commit_error));
9270
1/2
✓ Branch 0 taken 18173 times.
✗ Branch 1 not taken.
 18175 return finish_commit(thd);
9271 }
9272
9273 /*
9274 Shall introduce a delay only if it is going to do sync
9275 in this ongoing SYNC stage. The "+1" used below in the
9276 if condition is to count the ongoing sync stage.
9277 When sync_binlog=0 (where we never do sync in BGC group),
9278 it is considered as a special case and delay will be executed
9279 for every group just like how it is done when sync_binlog= 1.
9280 */
9281
6/6
✓ Branch 0 taken 5805091 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 5803657 times.
✓ Branch 3 taken 1434 times.
✓ Branch 4 taken 5803657 times.
✓ Branch 5 taken 1438 times.
 5805095 if (!flush_error && (sync_counter + 1 >= get_sync_period()))
9282
2/4
✓ Branch 0 taken 5803657 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5803657 times.
✗ Branch 3 not taken.
 5803657 Commit_stage_manager::get_instance().wait_count_or_timeout(
9283 opt_binlog_group_commit_sync_no_delay_count,
9284 opt_binlog_group_commit_sync_delay, Commit_stage_manager::SYNC_STAGE);
9285
9286
2/4
✓ Branch 0 taken 5805097 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5805097 times.
✗ Branch 3 not taken.
 5805095 final_queue = Commit_stage_manager::get_instance().fetch_queue_acquire_lock(
9287 Commit_stage_manager::SYNC_STAGE);
9288
9289
3/4
✓ Branch 0 taken 5805091 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 5805091 times.
✗ Branch 3 not taken.
 5805097 if (flush_error == 0 && total_bytes > 0) {
9290
3/4
✓ Branch 0 taken 5802441 times.
✓ Branch 1 taken 2650 times.
✓ Branch 2 taken 5802441 times.
✗ Branch 3 not taken.
 5805091 DEBUG_SYNC(thd, "before_sync_binlog_file");
9291
1/2
✓ Branch 0 taken 5805091 times.
✗ Branch 1 not taken.
 5805091 std::pair<bool, bool> result = sync_binlog_file(false);
9292 5805091 sync_error = result.first;
9293 }
9294
9295
2/2
✓ Branch 0 taken 5728506 times.
✓ Branch 1 taken 76591 times.
 5805097 if (update_binlog_end_pos_after_sync) {
9296 5728506 THD *tmp_thd = final_queue;
9297 5728506 const char *binlog_file = nullptr;
9298 5728506 my_off_t pos = 0;
9299
2/2
✓ Branch 0 taken 81601 times.
✓ Branch 1 taken 5728506 times.
 5810107 while (tmp_thd->next_to_commit != nullptr)
9300 81601 tmp_thd = tmp_thd->next_to_commit;
9301
4/4
✓ Branch 0 taken 5728500 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 5728496 times.
✓ Branch 3 taken 4 times.
 5728506 if (flush_error == 0 && sync_error == 0) {
9302
1/2
✓ Branch 0 taken 5728496 times.
✗ Branch 1 not taken.
 5728496 tmp_thd->get_trans_fixed_pos(&binlog_file, &pos);
9303
1/2
✓ Branch 0 taken 5728496 times.
✗ Branch 1 not taken.
 5728496 update_binlog_end_pos(binlog_file, pos);
9304 }
9305 }
9306
9307
3/4
✓ Branch 0 taken 5802447 times.
✓ Branch 1 taken 2650 times.
✓ Branch 2 taken 5802447 times.
✗ Branch 3 not taken.
 5805097 DEBUG_SYNC(thd, "bgc_after_sync_stage_before_commit_stage");
9308
9309 5805097 leave_mutex_before_commit_stage = &LOCK_sync;
9310 /*
9311 Stage #3: Commit all transactions in order.
9312
9313 This stage is skipped if we do not need to order the commits and
9314 each thread have to execute the handlerton commit instead.
9315
9316 However, since we are keeping the lock from the previous stage, we
9317 need to unlock it if we skip the stage.
9318
9319 We must also step commit_clock before the ha_commit_low() is called
9320 either in ordered fashion (by the leader of this stage) or by the thread
9321 themselves.
9322
9323 We are delaying the handling of sync error until
9324 all locks are released but we should not enter into
9325 commit stage if binlog_error_action is ABORT_SERVER.
9326 */
9327 5805098 commit_stage:
9328 /* Clone needs binlog commit order. */
9329
7/8
✓ Branch 0 taken 621 times.
✓ Branch 1 taken 5804477 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 621 times.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 5804473 times.
✓ Branch 6 taken 5804477 times.
✓ Branch 7 taken 621 times.
 5805102 if ((opt_binlog_order_commits || Clone_handler::need_commit_order()) &&
9330
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 (sync_error == 0 || binlog_error_action != ABORT_SERVER)) {
9331
3/4
✓ Branch 0 taken 5804468 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31777 times.
✓ Branch 3 taken 5772691 times.
 5804477 if (change_stage(thd, Commit_stage_manager::COMMIT_STAGE, final_queue,
9332 leave_mutex_before_commit_stage, &LOCK_commit)) {
9333
3/8
✓ Branch 0 taken 31777 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31777 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 31777 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 31777 DBUG_PRINT("return", ("Thread ID: %u, commit_error: %d", thd->thread_id(),
9334 thd->commit_error));
9335
1/2
✓ Branch 0 taken 31765 times.
✗ Branch 1 not taken.
 31777 return finish_commit(thd);
9336 }
9337 THD *commit_queue =
9338
2/4
✓ Branch 0 taken 5772700 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5772700 times.
✗ Branch 3 not taken.
 5772691 Commit_stage_manager::get_instance().fetch_queue_acquire_lock(
9339 Commit_stage_manager::COMMIT_STAGE);
9340
5/8
✓ Branch 0 taken 5772700 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 200 times.
✓ Branch 3 taken 5772500 times.
✓ Branch 4 taken 200 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 200 times.
✗ Branch 7 not taken.
 5772700 DBUG_EXECUTE_IF("semi_sync_3-way_deadlock",
9341 DEBUG_SYNC(thd, "before_process_commit_stage_queue"););
9342
9343
4/4
✓ Branch 0 taken 5772694 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 5772690 times.
✓ Branch 3 taken 4 times.
 5772700 if (flush_error == 0 && sync_error == 0)
9344
1/2
✓ Branch 0 taken 5772690 times.
✗ Branch 1 not taken.
 5772690 sync_error = call_after_sync_hook(commit_queue);
9345
9346 /*
9347 process_commit_stage_queue will call update_on_commit or
9348 update_on_rollback for the GTID owned by each thd in the queue.
9349
9350 This will be done this way to guarantee that GTIDs are added to
9351 gtid_executed in order, to avoid creating unnecessary temporary
9352 gaps and keep gtid_executed as a single interval at all times.
9353
9354 If we allow each thread to call update_on_commit only when they
9355 are at finish_commit, the GTID order cannot be guaranteed and
9356 temporary gaps may appear in gtid_executed. When this happen,
9357 the server would have to add and remove intervals from the
9358 Gtid_set, and adding and removing intervals requires a mutex,
9359 which would reduce performance.
9360 */
9361
1/2
✓ Branch 0 taken 5772687 times.
✗ Branch 1 not taken.
 5772700 process_commit_stage_queue(thd, commit_queue);
9362
1/2
✓ Branch 0 taken 5772686 times.
✗ Branch 1 not taken.
 5772687 mysql_mutex_unlock(&LOCK_commit);
9363 /*
9364 Process after_commit after LOCK_commit is released for avoiding
9365 3-way deadlock among user thread, rotate thread and dump thread.
9366 */
9367
1/2
✓ Branch 0 taken 5772683 times.
✗ Branch 1 not taken.
 5772686 process_after_commit_stage_queue(thd, commit_queue);
9368 5772683 final_queue = commit_queue;
9369 } else {
9370
1/2
✓ Branch 0 taken 621 times.
✗ Branch 1 not taken.
 621 if (leave_mutex_before_commit_stage)
9371
1/2
✓ Branch 0 taken 621 times.
✗ Branch 1 not taken.
 621 mysql_mutex_unlock(leave_mutex_before_commit_stage);
9372
2/4
✓ Branch 0 taken 621 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 621 times.
✗ Branch 3 not taken.
 621 if (flush_error == 0 && sync_error == 0)
9373
1/2
✓ Branch 0 taken 621 times.
✗ Branch 1 not taken.
 621 sync_error = call_after_sync_hook(final_queue);
9374 }
9375
9376 /*
9377 Handle sync error after we release all locks in order to avoid deadlocks
9378 */
9379
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 5773297 times.
 5773304 if (sync_error)
9380
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 handle_binlog_flush_or_sync_error(thd, true /* need_lock_log */, nullptr);
9381
9382
3/4
✓ Branch 0 taken 5770655 times.
✓ Branch 1 taken 2650 times.
✓ Branch 2 taken 5770658 times.
✗ Branch 3 not taken.
 5773304 DEBUG_SYNC(thd, "before_signal_done");
9383 /* Commit done so signal all waiting threads */
9384
2/4
✓ Branch 0 taken 5773306 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5773308 times.
✗ Branch 3 not taken.
 5773308 Commit_stage_manager::get_instance().signal_done(final_queue);
9385
2/8
✓ Branch 0 taken 5773308 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5773308 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 5773308 DBUG_EXECUTE_IF("block_leader_after_delete", {
9386 const char action[] = "now SIGNAL leader_proceed";
9387 assert(!debug_sync_set_action(thd, STRING_WITH_LEN(action)));
9388 };);
9389
9390 /*
9391 Finish the commit before executing a rotate, or run the risk of a
9392 deadlock. We don't need the return value here since it is in
9393 thd->commit_error, which is returned below.
9394 */
9395
1/2
✓ Branch 0 taken 5773301 times.
✗ Branch 1 not taken.
 5773308 (void)finish_commit(thd);
9396
3/4
✓ Branch 0 taken 5770653 times.
✓ Branch 1 taken 2651 times.
✓ Branch 2 taken 5770658 times.
✗ Branch 3 not taken.
 5773301 DEBUG_SYNC(thd, "bgc_after_commit_stage_before_rotation");
9397
9398 /*
9399 If we need to rotate, we do it without commit error.
9400 Otherwise the thd->commit_error will be possibly reset.
9401 */
9402
7/8
✓ Branch 0 taken 5773307 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5773303 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 13410 times.
✓ Branch 5 taken 5759893 times.
✓ Branch 6 taken 12248 times.
✓ Branch 7 taken 5761059 times.
 5786719 if (DBUG_EVALUATE_IF("force_rotate", 1, 0) ||
9403
2/2
✓ Branch 0 taken 12244 times.
✓ Branch 1 taken 1166 times.
 13410 (do_rotate && thd->commit_error == THD::CE_NONE &&
9404
1/2
✓ Branch 0 taken 12244 times.
✗ Branch 1 not taken.
 12244 !is_rotating_caused_by_incident)) {
9405 /*
9406 Do not force the rotate as several consecutive groups may
9407 request unnecessary rotations.
9408
9409 NOTE: Run purge_logs wo/ holding LOCK_log because it does not
9410 need the mutex. Otherwise causes various deadlocks.
9411 */
9412
9413
2/4
✓ Branch 0 taken 12247 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12248 times.
✗ Branch 3 not taken.
 12248 DEBUG_SYNC(thd, "ready_to_do_rotation");
9414 12248 bool check_purge = false;
9415
1/2
✓ Branch 0 taken 12249 times.
✗ Branch 1 not taken.
 12248 mysql_mutex_lock(&LOCK_log);
9416 /*
9417 If rotate fails then depends on binlog_error_action variable
9418 appropriate action will be taken inside rotate call.
9419 */
9420
1/2
✓ Branch 0 taken 12249 times.
✗ Branch 1 not taken.
 12249 int error = rotate(false, &check_purge);
9421
1/2
✓ Branch 0 taken 12249 times.
✗ Branch 1 not taken.
 12249 mysql_mutex_unlock(&LOCK_log);
9422
9423
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 12238 times.
 12249 if (error)
9424 11 thd->commit_error = THD::CE_COMMIT_ERROR;
9425
2/2
✓ Branch 0 taken 6944 times.
✓ Branch 1 taken 5294 times.
 12238 else if (check_purge)
9426
1/2
✓ Branch 0 taken 6944 times.
✗ Branch 1 not taken.
 6944 auto_purge();
9427 }
9428
9429
6/6
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 5773280 times.
✓ Branch 2 taken 25 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 18 times.
✓ Branch 5 taken 5773290 times.
 5773333 if (binlog_space_limit && binlog_space_total &&
9430
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 7 times.
 25 binlog_space_total + m_binlog_file->position() > binlog_space_limit)
9431
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
 18 purge_logs_by_size(true);
9432
9433 /*
9434 flush or sync errors are handled above (using binlog_error_action).
9435 Hence treat only COMMIT_ERRORs as errors.
9436 */
9437 5773303 return thd->commit_error == THD::CE_COMMIT_ERROR;
9438 5926297 }
9439
9440 /** Copy the current binlog coordinates to the variables used for the
9441 not-in-consistent-snapshot case of SHOW STATUS */
9442 5832998 void MYSQL_BIN_LOG::publish_coordinates_for_global_status(void) const {
9443 5832998 mysql_mutex_assert_owner(&LOCK_log);
9444
9445 5832998 mysql_mutex_lock(&LOCK_status);
9446 5832998 strcpy(binlog_global_snapshot_file, log_file_name);
9447 5832998 binlog_global_snapshot_position = m_binlog_file->position();
9448 5832998 mysql_mutex_unlock(&LOCK_status);
9449 5832998 }
9450
9451 213 void MYSQL_BIN_LOG::xlock(void) {
9452 213 mysql_mutex_lock(&LOCK_log);
9453
9454
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 213 times.
 213 assert(!snapshot_lock_acquired);
9455
9456 /*
9457 We must ensure that no writes to binlog and no commits to storage engines
9458 occur after function is called for START TRANSACTION FOR CONSISTENT
9459 SNAPSHOT. With binlog_order_commits=1 (the default) flushing to binlog is
9460 performed under the LOCK_log mutex and commits are done under the
9461 LOCK_commit mutex, both in the stage leader thread. So acquiring those 2
9462 mutexes is sufficient to guarantee atomicity.
9463
9464 With binlog_order_commits=0 commits are performed in parallel by separate
9465 threads with each acquiring a shared lock on LOCK_consistent_snapshot.
9466
9467 binlog_order_commits is a dynamic variable, so we have to keep track what
9468 primitives should be used in xunlock().
9469 */
9470
1/2
✓ Branch 0 taken 213 times.
✗ Branch 1 not taken.
 213 if (opt_binlog_order_commits) {
9471 213 mysql_mutex_lock(&LOCK_commit);
9472 } else {
9473 ✗ snapshot_lock_acquired = true;
9474 ✗ mysql_rwlock_wrlock(&LOCK_consistent_snapshot);
9475 }
9476 213 }
9477
9478 213 void MYSQL_BIN_LOG::xunlock(void) {
9479
1/2
✓ Branch 0 taken 213 times.
✗ Branch 1 not taken.
 213 if (!snapshot_lock_acquired) {
9480 213 mysql_mutex_unlock(&LOCK_commit);
9481 } else {
9482 ✗ mysql_rwlock_unlock(&LOCK_consistent_snapshot);
9483 ✗ snapshot_lock_acquired = false;
9484 }
9485
9486 213 mysql_mutex_unlock(&LOCK_log);
9487 213 }
9488
9489 /*
9490 Copy out the non-directory part of binlog position filename for the
9491 `binlog_snapshot_file' status variable, same way as it is done for
9492 SHOW MASTER STATUS.
9493 */
9494 106704 static void set_binlog_snapshot_file(const char *src) {
9495 106704 mysql_mutex_assert_owner(&LOCK_status);
9496
9497 106704 int dir_len = dirname_length(src);
9498 106704 strmake(binlog_snapshot_file, src + dir_len,
9499 sizeof(binlog_snapshot_file) - 1);
9500 106704 }
9501
9502
9503
9504 9 void MYSQL_BIN_LOG::report_missing_purged_gtids(
9505 const Gtid_set *slave_executed_gtid_set, std::string &errmsg) {
9506
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 DBUG_TRACE;
9507
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 THD *thd = current_thd;
9508
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 Gtid_set gtid_missing(gtid_state->get_lost_gtids()->get_sid_map());
9509
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 gtid_missing.add_gtid_set(gtid_state->get_lost_gtids());
9510
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 gtid_missing.remove_gtid_set(slave_executed_gtid_set);
9511
9512 9 String tmp_uuid;
9513
9514 /* Protects thd->user_vars. */
9515
2/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
 9 mysql_mutex_lock(&current_thd->LOCK_thd_data);
9516
3/6
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
 9 const auto it = current_thd->user_vars.find("replica_uuid");
9517
4/8
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9 times.
✗ Branch 7 not taken.
 9 if (it != current_thd->user_vars.end() && it->second->length() > 0) {
9518
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 tmp_uuid.copy(it->second->ptr(), it->second->length(), nullptr);
9519 }
9520
2/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
 9 mysql_mutex_unlock(&current_thd->LOCK_thd_data);
9521
9522 9 char *missing_gtids = nullptr;
9523 9 char *slave_executed_gtids = nullptr;
9524
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 gtid_missing.to_string(&missing_gtids);
9525
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 slave_executed_gtid_set->to_string(&slave_executed_gtids);
9526
9527 /*
9528 Log the information about the missing purged GTIDs to the error log.
9529 */
9530
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 std::ostringstream log_info;
9531
3/6
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
 9 log_info << "The missing transactions are '" << missing_gtids << "'";
9532
9533
9/18
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 9 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 9 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 9 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 9 times.
✗ Branch 17 not taken.
 9 LogErr(WARNING_LEVEL, ER_FOUND_MISSING_GTIDS, tmp_uuid.ptr(),
9534 log_info.str().c_str());
9535
9536 /*
9537 Send the information about the slave executed GTIDs and missing
9538 purged GTIDs to slave if the message is less than MYSQL_ERRMSG_SIZE.
9539 */
9540
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 std::ostringstream gtid_info;
9541 gtid_info << "The GTID set sent by the slave is '" << slave_executed_gtids
9542
5/10
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✗ Branch 9 not taken.
 9 << "', and the missing transactions are '" << missing_gtids << "'";
9543
2/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
 9 errmsg.assign(ER_THD(thd, ER_MASTER_HAS_PURGED_REQUIRED_GTIDS));
9544
9545 /* Don't consider the "%s" in the format string. Subtract 2 from the
9546 total length */
9547
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 int total_length = (errmsg.length() - 2 + gtid_info.str().length());
9548
9549
3/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 6 times.
 9 DBUG_EXECUTE_IF("simulate_long_missing_gtids",
9550 { total_length = MYSQL_ERRMSG_SIZE + 1; });
9551
9552
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6 times.
 9 if (total_length > MYSQL_ERRMSG_SIZE)
9553
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 gtid_info.str(
9554 "The GTID sets and the missing purged transactions are too"
9555 " long to print in this message. For more information,"
9556 " please see the master's error log or the manual for"
9557 " GTID_SUBTRACT");
9558
9559 /* Buffer for formatting the message about the missing GTIDs. */
9560 9 char buff[MYSQL_ERRMSG_SIZE] = {0};
9561
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 snprintf(buff, MYSQL_ERRMSG_SIZE, errmsg.c_str(), gtid_info.str().c_str());
9562
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 errmsg.assign(buff);
9563
9564
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 my_free(missing_gtids);
9565
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 my_free(slave_executed_gtids);
9566 9 }
9567
9568 1 void MYSQL_BIN_LOG::report_missing_gtids(
9569 const Gtid_set *previous_gtid_set, const Gtid_set *slave_executed_gtid_set,
9570 std::string &errmsg) {
9571
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 DBUG_TRACE;
9572
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 THD *thd = current_thd;
9573 1 char *missing_gtids = nullptr;
9574 1 char *slave_executed_gtids = nullptr;
9575
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 Gtid_set gtid_missing(slave_executed_gtid_set->get_sid_map());
9576
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 gtid_missing.add_gtid_set(slave_executed_gtid_set);
9577
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 gtid_missing.remove_gtid_set(previous_gtid_set);
9578
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 gtid_missing.to_string(&missing_gtids);
9579
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 slave_executed_gtid_set->to_string(&slave_executed_gtids);
9580
9581 1 String tmp_uuid;
9582
9583 /* Protects thd->user_vars. */
9584
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 mysql_mutex_lock(&current_thd->LOCK_thd_data);
9585
3/6
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 1 const auto it = current_thd->user_vars.find("replica_uuid");
9586
4/8
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
 1 if (it != current_thd->user_vars.end() && it->second->length() > 0) {
9587
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 tmp_uuid.copy(it->second->ptr(), it->second->length(), nullptr);
9588 }
9589
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 mysql_mutex_unlock(&current_thd->LOCK_thd_data);
9590
9591 /*
9592 Log the information about the missing purged GTIDs to the error log.
9593 */
9594
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 std::ostringstream log_info;
9595 log_info << "If the binary log files have been deleted from disk,"
9596 " check the consistency of 'GTID_PURGED' variable."
9597 " The missing transactions are '"
9598
3/6
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 1 << missing_gtids << "'";
9599
9/18
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 1 times.
✗ Branch 17 not taken.
 1 LogErr(WARNING_LEVEL, ER_FOUND_MISSING_GTIDS, tmp_uuid.ptr(),
9600 log_info.str().c_str());
9601 /*
9602 Send the information about the slave executed GTIDs and missing
9603 purged GTIDs to slave if the message is less than MYSQL_ERRMSG_SIZE.
9604 */
9605
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 std::ostringstream gtid_info;
9606 gtid_info << "The GTID set sent by the slave is '" << slave_executed_gtids
9607
5/10
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
 1 << "', and the missing transactions are '" << missing_gtids << "'";
9608
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 errmsg.assign(ER_THD(thd, ER_MASTER_HAS_PURGED_REQUIRED_GTIDS));
9609
9610 /* Don't consider the "%s" in the format string. Subtract 2 from the
9611 total length */
9612
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if ((errmsg.length() - 2 + gtid_info.str().length()) > MYSQL_ERRMSG_SIZE)
9613 ✗ gtid_info.str(
9614 "The GTID sets and the missing purged transactions are too"
9615 " long to print in this message. For more information,"
9616 " please see the master's error log or the manual for"
9617 " GTID_SUBTRACT");
9618 /* Buffer for formatting the message about the missing GTIDs. */
9619 1 char buff[MYSQL_ERRMSG_SIZE] = {0};
9620
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 snprintf(buff, MYSQL_ERRMSG_SIZE, errmsg.c_str(), gtid_info.str().c_str());
9621
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 errmsg.assign(buff);
9622
9623
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 my_free(missing_gtids);
9624
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 my_free(slave_executed_gtids);
9625 1 }
9626
9627 1966785 void MYSQL_BIN_LOG::update_binlog_end_pos(bool need_lock) {
9628
2/2
✓ Branch 0 taken 191241 times.
✓ Branch 1 taken 1775544 times.
 1966785 if (need_lock)
9629 191241 lock_binlog_end_pos();
9630 else
9631 1775544 mysql_mutex_assert_owner(&LOCK_binlog_end_pos);
9632 1966785 atomic_binlog_end_pos = m_binlog_file->position();
9633 1966785 signal_update();
9634
2/2
✓ Branch 0 taken 191241 times.
✓ Branch 1 taken 1775544 times.
 1966785 if (need_lock) unlock_binlog_end_pos();
9635 1966785 }
9636
9637 5728496 inline void MYSQL_BIN_LOG::update_binlog_end_pos(const char *file,
9638 my_off_t pos) {
9639 5728496 lock_binlog_end_pos();
9640
6/6
✓ Branch 0 taken 5728495 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 5728494 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 5728494 times.
✓ Branch 5 taken 2 times.
 5728496 if (is_active(file) && (pos > atomic_binlog_end_pos))
9641 5728494 atomic_binlog_end_pos = pos;
9642 5728496 signal_update();
9643 5728496 unlock_binlog_end_pos();
9644 5728496 }
9645
9646 5791540 bool THD::is_binlog_cache_empty(bool is_transactional) const {
9647
1/2
✓ Branch 0 taken 5791559 times.
✗ Branch 1 not taken.
 5791540 DBUG_TRACE;
9648
9649 // If opt_bin_log==0, it is not safe to call thd_get_cache_mngr
9650 // because binlog_hton has not been completely set up.
9651
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5791559 times.
 5791559 assert(opt_bin_log);
9652
1/2
✓ Branch 0 taken 5791573 times.
✗ Branch 1 not taken.
 5791559 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(this);
9653
9654 // cache_mngr is NULL until we call thd->binlog_setup_trx_data, so
9655 // we assert that this has been done.
9656
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5791573 times.
 5791573 assert(cache_mngr != nullptr);
9657
9658 binlog_cache_data *cache_data =
9659 5791573 cache_mngr->get_binlog_cache_data(is_transactional);
9660
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5791536 times.
 5791536 assert(cache_data != nullptr);
9661
9662
1/2
✓ Branch 0 taken 5791573 times.
✗ Branch 1 not taken.
 11583110 return cache_data->is_binlog_empty();
9663 5791573 }
9664
9665 /*
9666 These functions are placed in this file since they need access to
9667 binlog_hton, which has internal linkage.
9668 */
9669
9670 16974669 int THD::binlog_setup_trx_data() {
9671
1/2
✓ Branch 0 taken 16975106 times.
✗ Branch 1 not taken.
 16974669 DBUG_TRACE;
9672
1/2
✓ Branch 0 taken 16974957 times.
✗ Branch 1 not taken.
 16975106 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(this);
9673
9674
2/2
✓ Branch 0 taken 16928315 times.
✓ Branch 1 taken 46642 times.
 16974957 if (cache_mngr) /* Already set up */ {
9675 16928021 if (Rpl_thd_context::TX_RPL_STAGE_BEGIN ==
9676
3/4
✓ Branch 0 taken 16928021 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 98193 times.
✓ Branch 3 taken 16829828 times.
 16928315 rpl_thd_ctx.get_tx_rpl_delegate_stage_status())
9677
1/2
✓ Branch 0 taken 98253 times.
✗ Branch 1 not taken.
 98193 rpl_thd_ctx.set_tx_rpl_delegate_stage_status(
9678 Rpl_thd_context::TX_RPL_STAGE_CACHE_CREATED);
9679 16928081 return 0;
9680 }
9681
9682
1/2
✓ Branch 0 taken 46675 times.
✗ Branch 1 not taken.
 46642 cache_mngr = (binlog_cache_mngr *)my_malloc(key_memory_binlog_cache_mngr,
9683 sizeof(binlog_cache_mngr),
9684 MYF(MY_ZEROFILL));
9685
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46675 times.
 46675 if (!cache_mngr) {
9686 ✗ return 1; // Didn't manage to set it up
9687 }
9688
9689 93349 cache_mngr = new (cache_mngr)
9690 binlog_cache_mngr(&binlog_stmt_cache_use, &binlog_stmt_cache_disk_use,
9691
1/2
✓ Branch 0 taken 46674 times.
✗ Branch 1 not taken.
 46675 &binlog_cache_use, &binlog_cache_disk_use);
9692
2/4
✓ Branch 0 taken 46677 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 46677 times.
 46674 if (cache_mngr->init()) {
9693 ✗ cache_mngr->~binlog_cache_mngr();
9694 ✗ my_free(cache_mngr);
9695 ✗ return 1;
9696 }
9697 46675 if (Rpl_thd_context::TX_RPL_STAGE_BEGIN ==
9698
3/4
✓ Branch 0 taken 46675 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5968 times.
✓ Branch 3 taken 40707 times.
 46677 rpl_thd_ctx.get_tx_rpl_delegate_stage_status())
9699
1/2
✓ Branch 0 taken 5968 times.
✗ Branch 1 not taken.
 5968 rpl_thd_ctx.set_tx_rpl_delegate_stage_status(
9700 Rpl_thd_context::TX_RPL_STAGE_CACHE_CREATED);
9701
9702
3/8
✓ Branch 0 taken 46676 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46677 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 46677 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 46675 DBUG_PRINT("debug", ("Set ha_data slot %d to 0x%llx", binlog_hton->slot,
9703 (ulonglong)cache_mngr));
9704
1/2
✓ Branch 0 taken 46677 times.
✗ Branch 1 not taken.
 46677 thd_set_ha_data(this, binlog_hton, cache_mngr);
9705
9706 46677 return 0;
9707 16974758 }
9708
9709 /**
9710
9711 */
9712 11028744 void register_binlog_handler(THD *thd, bool trx) {
9713
1/2
✓ Branch 0 taken 11029290 times.
✗ Branch 1 not taken.
 11028744 DBUG_TRACE;
9714 /*
9715 If this is the first call to this function while processing a statement,
9716 the transactional cache does not have a savepoint defined. So, in what
9717 follows:
9718 . an implicit savepoint is defined;
9719 . callbacks are registered;
9720 . binary log is set as read/write.
9721
9722 The savepoint allows for truncating the trx-cache transactional changes
9723 fail. Callbacks are necessary to flush caches upon committing or rolling
9724 back a statement or a transaction. However, notifications do not happen
9725 if the binary log is set as read/write.
9726 */
9727
1/2
✓ Branch 0 taken 11029471 times.
✗ Branch 1 not taken.
 11029290 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd);
9728
2/2
✓ Branch 0 taken 11014750 times.
✓ Branch 1 taken 14490 times.
 11029471 if (cache_mngr->trx_cache.get_prev_position() == MY_OFF_T_UNDEF) {
9729 /*
9730 Set an implicit savepoint in order to be able to truncate a trx-cache.
9731 */
9732 11014750 my_off_t pos = 0;
9733
1/2
✓ Branch 0 taken 11014842 times.
✗ Branch 1 not taken.
 11014750 binlog_trans_log_savepos(thd, &pos);
9734
1/2
✓ Branch 0 taken 11014883 times.
✗ Branch 1 not taken.
 11014842 cache_mngr->trx_cache.set_prev_position(pos);
9735
9736 /*
9737 Set callbacks in order to be able to call commit or rollback.
9738 */
9739
3/4
✓ Branch 0 taken 5867119 times.
✓ Branch 1 taken 5147764 times.
✓ Branch 2 taken 5867111 times.
✗ Branch 3 not taken.
 11014883 if (trx) trans_register_ha(thd, true, binlog_hton, nullptr);
9740
1/2
✓ Branch 0 taken 11014867 times.
✗ Branch 1 not taken.
 11014875 trans_register_ha(thd, false, binlog_hton, nullptr);
9741
9742 /*
9743 Set the binary log as read/write otherwise callbacks are not called.
9744 */
9745
2/4
✓ Branch 0 taken 11014968 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11014890 times.
✗ Branch 3 not taken.
 11014867 thd->get_ha_data(binlog_hton->slot)->ha_info[0].set_trx_read_write();
9746 }
9747 11029380 }
9748
9749 /**
9750 Function to start a statement and optionally a transaction for the
9751 binary log.
9752
9753 This function does three things:
9754 - Starts a transaction if not in autocommit mode or if a BEGIN
9755 statement has been seen.
9756
9757 - Start a statement transaction to allow us to truncate the cache.
9758
9759 - Save the current binlog position so that we can roll back the
9760 statement by truncating the cache.
9761
9762 We only update the saved position if the old one was undefined,
9763 the reason is that there are some cases (e.g., for CREATE-SELECT)
9764 where the position is saved twice (e.g., both in
9765 Query_result_create::prepare() and THD::binlog_write_table_map()), but
9766 we should use the first. This means that calls to this function
9767 can be used to start the statement before the first table map
9768 event, to include some extra events.
9769
9770 Note however that IMMEDIATE_LOGGING implies that the statement is
9771 written without BEGIN/COMMIT.
9772
9773 @param thd Thread variable
9774 @param start_event The first event requested to be written into the
9775 binary log
9776 */
9777 11132673 static int binlog_start_trans_and_stmt(THD *thd, Log_event *start_event) {
9778
1/2
✓ Branch 0 taken 11132882 times.
✗ Branch 1 not taken.
 11132673 DBUG_TRACE;
9779
9780 /*
9781 Initialize the cache manager if this was not done yet.
9782 */
9783
2/4
✓ Branch 0 taken 11132775 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11132775 times.
 11132882 if (thd->binlog_setup_trx_data()) return 1;
9784
9785 /*
9786 Retrieve the appropriated cache.
9787 */
9788 11132775 bool is_transactional = start_event->is_using_trans_cache();
9789
1/2
✓ Branch 0 taken 11133196 times.
✗ Branch 1 not taken.
 11132665 binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd);
9790 binlog_cache_data *cache_data =
9791 11133196 cache_mngr->get_binlog_cache_data(is_transactional);
9792
9793 /*
9794 If the event is requesting immediate logging, there is no need to go
9795 further down and set savepoint and register callbacks.
9796 */
9797
2/2
✓ Branch 0 taken 103648 times.
✓ Branch 1 taken 11029030 times.
 11132589 if (start_event->is_using_immediate_logging()) return 0;
9798
9799
1/2
✓ Branch 0 taken 11029425 times.
✗ Branch 1 not taken.
 11029030 register_binlog_handler(thd, thd->in_multi_stmt_transaction_mode());
9800
9801 /* Transactional DDL is logged traditionally without BEGIN. */
9802
2/2
✓ Branch 0 taken 265694 times.
✓ Branch 1 taken 10763222 times.
 11029425 if (is_atomic_ddl_event(start_event)) return 0;
9803
9804 /*
9805 If the cache is empty log "BEGIN" at the beginning of every transaction.
9806 Here, a transaction is either a BEGIN..COMMIT/ROLLBACK block or a single
9807 statement in autocommit mode.
9808 */
9809
3/4
✓ Branch 0 taken 10763623 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5512204 times.
✓ Branch 3 taken 5251419 times.
 10763222 if (cache_data->is_binlog_empty()) {
9810 static const char begin[] = "BEGIN";
9811 5512204 const char *query = nullptr;
9812 char buf[XID::ser_buf_size];
9813 char xa_start[sizeof("XA START") + 1 + sizeof(buf)];
9814 5512204 XID_STATE *xs = thd->get_transaction()->xid_state();
9815 5512279 int qlen = sizeof(begin) - 1;
9816
9817
6/6
✓ Branch 0 taken 5134130 times.
✓ Branch 1 taken 378149 times.
✓ Branch 2 taken 660 times.
✓ Branch 3 taken 5133491 times.
✓ Branch 4 taken 660 times.
✓ Branch 5 taken 5511640 times.
 5512279 if (is_transactional && xs->has_state(XID_STATE::XA_ACTIVE)) {
9818 /*
9819 XA-prepare logging case.
9820 */
9821 660 qlen = sprintf(xa_start, "XA START %s", xs->get_xid()->serialize(buf));
9822 660 query = xa_start;
9823 } else {
9824 /*
9825 Regular transaction case.
9826 */
9827 5511640 query = begin;
9828 }
9829
9830 Query_log_event qinfo(thd, query, qlen, is_transactional, false, true, 0,
9831
1/2
✓ Branch 0 taken 5511763 times.
✗ Branch 1 not taken.
 5512300 true);
9832
2/4
✓ Branch 0 taken 5512222 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5512222 times.
 5511763 if (cache_data->write_event(&qinfo)) return 1;
9833
1/2
✓ Branch 0 taken 5511624 times.
✗ Branch 1 not taken.
 5512222 }
9834
9835 10763043 return 0;
9836 11132346 }
9837
9838 /**
9839 This function writes a table map to the binary log.
9840 Note that in order to keep the signature uniform with related methods,
9841 we use a redundant parameter to indicate whether a transactional table
9842 was changed or not.
9843 Sometimes it will write a Rows_query_log_event into binary log before
9844 the table map too.
9845
9846 @param table a pointer to the table.
9847 @param is_transactional @c true indicates a transactional table,
9848 otherwise @c false a non-transactional.
9849 @param binlog_rows_query @c true indicates a Rows_query log event
9850 will be binlogged before table map,
9851 otherwise @c false indicates it will not
9852 be binlogged.
9853 @return
9854 nonzero if an error pops up when writing the table map event
9855 or the Rows_query log event.
9856 */
9857 10438262 int THD::binlog_write_table_map(TABLE *table, bool is_transactional,
9858 bool binlog_rows_query) {
9859 int error;
9860
1/2
✓ Branch 0 taken 10438635 times.
✗ Branch 1 not taken.
 10438262 DBUG_TRACE;
9861
5/8
✓ Branch 0 taken 10438516 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10438597 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 16 times.
✓ Branch 5 taken 10438581 times.
✓ Branch 6 taken 16 times.
✗ Branch 7 not taken.
 10438635 DBUG_PRINT("enter", ("table: %p (%s: #%llu)", table, table->s->table_name.str,
9862 table->s->table_map_id.id()));
9863
9864 /* Pre-conditions */
9865
3/4
✓ Branch 0 taken 10438561 times.
✓ Branch 1 taken 54 times.
✓ Branch 2 taken 10438629 times.
✗ Branch 3 not taken.
 10438597 assert(is_current_stmt_binlog_format_row() && mysql_bin_log.is_open());
9866
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10438257 times.
 10438629 assert(table->s->table_map_id.is_valid());
9867
9868 10438257 Table_map_log_event the_event(this, table, table->s->table_map_id,
9869
1/2
✓ Branch 0 taken 10438457 times.
✗ Branch 1 not taken.
 10438257 is_transactional);
9870
9871
1/2
✓ Branch 0 taken 10438611 times.
✗ Branch 1 not taken.
 10438457 binlog_start_trans_and_stmt(this, &the_event);
9872
9873
1/2
✓ Branch 0 taken 10438614 times.
✗ Branch 1 not taken.
 10438611 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(this);
9874
9875 binlog_cache_data *cache_data =
9876 10438614 cache_mngr->get_binlog_cache_data(is_transactional);
9877
9878
7/8
✓ Branch 0 taken 71 times.
✓ Branch 1 taken 10438541 times.
✓ Branch 2 taken 73 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 71 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 71 times.
✓ Branch 7 taken 10438543 times.
 10438612 if (binlog_rows_query && this->query().str) {
9879 /* Write the Rows_query_log_event into binlog before the table map */
9880 142 Rows_query_log_event rows_query_ev(this, this->query().str,
9881
3/6
✓ Branch 0 taken 71 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 71 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 71 times.
✗ Branch 5 not taken.
 71 this->query().length);
9882
2/4
✓ Branch 0 taken 71 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 71 times.
 71 if ((error = cache_data->write_event(&rows_query_ev))) return error;
9883
1/2
✓ Branch 0 taken 71 times.
✗ Branch 1 not taken.
 71 }
9884
9885
2/4
✓ Branch 0 taken 10438632 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10438632 times.
 10438614 if ((error = cache_data->write_event(&the_event))) return error;
9886
9887 10438632 binlog_table_maps++;
9888 10438632 return 0;
9889 10438632 }
9890
9891 /**
9892 This function retrieves a pending row event from a cache which is
9893 specified through the parameter @c is_transactional. Respectively, when it
9894 is @c true, the pending event is returned from the transactional cache.
9895 Otherwise from the non-transactional cache.
9896
9897 @param is_transactional @c true indicates a transactional cache,
9898 otherwise @c false a non-transactional.
9899 @return
9900 The row event if any.
9901 */
9902 154366012 Rows_log_event *THD::binlog_get_pending_rows_event(
9903 bool is_transactional) const {
9904 154366012 Rows_log_event *rows = nullptr;
9905 154366012 binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(this);
9906
9907 /*
9908 This is less than ideal, but here's the story: If there is no cache_mngr,
9909 prepare_pending_rows_event() has never been called (since the cache_mngr
9910 is set up there). In that case, we just return NULL.
9911 */
9912
2/2
✓ Branch 0 taken 133311451 times.
✓ Branch 1 taken 21063534 times.
 154374985 if (cache_mngr) {
9913 binlog_cache_data *cache_data =
9914 133311451 cache_mngr->get_binlog_cache_data(is_transactional);
9915
9916 133291681 rows = cache_data->pending();
9917 }
9918 154374964 return (rows);
9919 }
9920
9921 /**
9922 @param db_param db name c-string to be inserted into alphabetically sorted
9923 THD::binlog_accessed_db_names list.
9924
9925 Note, that space for both the data and the node
9926 struct are allocated in THD::main_mem_root.
9927 The list lasts for the top-level query time and is reset
9928 in @c THD::cleanup_after_query().
9929 */
9930 1494686 void THD::add_to_binlog_accessed_dbs(const char *db_param) {
9931 char *after_db;
9932 /*
9933 binlog_accessed_db_names list is to maintain the database
9934 names which are referenced in a given command.
9935 Prior to bug 17806014 fix, 'main_mem_root' memory root used
9936 to store this list. The 'main_mem_root' scope is till the end
9937 of the query. Hence it caused increasing memory consumption
9938 problem in big procedures like the ones mentioned below.
9939 Eg: CALL p1() where p1 is having 1,00,000 create and drop tables.
9940 'main_mem_root' is freed only at the end of the command CALL p1()'s
9941 execution. But binlog_accessed_db_names list scope is only till the
9942 individual statements specified the procedure(create/drop statements).
9943 Hence the memory allocated in 'main_mem_root' was left uncleared
9944 until the p1's completion, even though it is not required after
9945 completion of individual statements.
9946
9947 Instead of using 'main_mem_root' whose scope is complete query execution,
9948 now the memroot is changed to use 'thd->mem_root' whose scope is until the
9949 individual statement in CALL p1(). 'thd->mem_root' is set to
9950 'execute_mem_root' in the context of procedure and it's scope is till the
9951 individual statement in CALL p1() and thd->memroot is equal to
9952 'main_mem_root' in the context of a normal 'top level query'.
9953
9954 Eg: a) create table t1(i int); => If this function is called while
9955 processing this statement, thd->memroot is equal to &main_mem_root
9956 which will be freed immediately after executing this statement.
9957 b) CALL p1() -> p1 contains create table t1(i int); => If this function
9958 is called while processing create table statement which is inside
9959 a stored procedure, then thd->memroot is equal to 'execute_mem_root'
9960 which will be freed immediately after executing this statement.
9961 In both a and b case, thd->memroot will be freed immediately and will not
9962 increase memory consumption.
9963
9964 A special case(stored functions/triggers):
9965 Consider the following example:
9966 create function f1(i int) returns int
9967 begin
9968 insert into db1.t1 values (1);
9969 insert into db2.t1 values (2);
9970 end;
9971 When we are processing SELECT f1(), the list should contain db1, db2 names.
9972 Since thd->mem_root contains 'execute_mem_root' in the context of
9973 stored function, the mem root will be freed after adding db1 in
9974 the list and when we are processing the second statement and when we try
9975 to add 'db2' in the db1's list, it will lead to crash as db1's memory
9976 is already freed. To handle this special case, if in_sub_stmt is set
9977 (which is true in case of stored functions/triggers), we use &main_mem_root,
9978 if not set we will use thd->memroot which changes it's value to
9979 'execute_mem_root' or '&main_mem_root' depends on the context.
9980 */
9981
2/2
✓ Branch 0 taken 359 times.
✓ Branch 1 taken 1494327 times.
 1494686 MEM_ROOT *db_mem_root = in_sub_stmt ? &main_mem_root : mem_root;
9982
9983
2/2
✓ Branch 0 taken 1190191 times.
✓ Branch 1 taken 304495 times.
 1494686 if (!binlog_accessed_db_names)
9984
1/2
✓ Branch 0 taken 1190201 times.
✗ Branch 1 not taken.
 1190191 binlog_accessed_db_names = new (db_mem_root) List<char>;
9985
9986
2/2
✓ Branch 0 taken 392 times.
✓ Branch 1 taken 1494225 times.
 1494617 if (binlog_accessed_db_names->elements > MAX_DBS_IN_EVENT_MTS) {
9987 392 push_warning_printf(
9988 this, Sql_condition::SL_WARNING, ER_MTS_UPDATED_DBS_GREATER_MAX,
9989 ER_THD(this, ER_MTS_UPDATED_DBS_GREATER_MAX), MAX_DBS_IN_EVENT_MTS);
9990 392 return;
9991 }
9992
9993 1494225 after_db = strdup_root(db_mem_root, db_param);
9994
9995 /*
9996 sorted insertion is implemented with first rearranging data
9997 (pointer to char*) of the links and final appending of the least
9998 ordered data to create a new link in the list.
9999 */
10000
2/2
✓ Branch 0 taken 304230 times.
✓ Branch 1 taken 1190336 times.
 1494566 if (binlog_accessed_db_names->elements != 0) {
10001
1/2
✓ Branch 0 taken 304230 times.
✗ Branch 1 not taken.
 304230 List_iterator<char> it(*get_binlog_accessed_db_names());
10002
10003
2/2
✓ Branch 0 taken 377220 times.
✓ Branch 1 taken 14834 times.
 392054 while (it++) {
10004 377220 char *swap = nullptr;
10005 377220 char **ref_cur_db = it.ref();
10006 377220 int cmp = strcmp(after_db, *ref_cur_db);
10007
10008
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 377220 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 377220 assert(!swap || cmp < 0);
10009
10010
2/2
✓ Branch 0 taken 289396 times.
✓ Branch 1 taken 87824 times.
 377220 if (cmp == 0) {
10011 289396 after_db = nullptr; /* dup to ignore */
10012 289396 break;
10013
3/4
✓ Branch 0 taken 87824 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17859 times.
✓ Branch 3 taken 69965 times.
 87824 } else if (swap || cmp > 0) {
10014 17859 swap = *ref_cur_db;
10015 17859 *ref_cur_db = after_db;
10016 17859 after_db = swap;
10017 }
10018 }
10019 }
10020
2/2
✓ Branch 0 taken 1204848 times.
✓ Branch 1 taken 289718 times.
 1494566 if (after_db) binlog_accessed_db_names->push_back(after_db, db_mem_root);
10021 }
10022
10023 /*
10024 Tells if two (or more) tables have auto_increment columns and we want to
10025 lock those tables with a write lock.
10026
10027 SYNOPSIS
10028 has_two_write_locked_tables_with_auto_increment
10029 tables Table list
10030
10031 NOTES:
10032 Call this function only when you have established the list of all tables
10033 which you'll want to update (including stored functions, triggers, views
10034 inside your statement).
10035 */
10036
10037 858935 static bool has_write_table_with_auto_increment(TABLE_LIST *tables) {
10038
2/2
✓ Branch 0 taken 1691383 times.
✓ Branch 1 taken 745546 times.
 2436929 for (TABLE_LIST *table = tables; table; table = table->next_global) {
10039 /* we must do preliminary checks as table->table may be NULL */
10040
6/6
✓ Branch 0 taken 1508778 times.
✓ Branch 1 taken 183064 times.
✓ Branch 2 taken 548755 times.
✓ Branch 3 taken 960023 times.
✓ Branch 4 taken 113848 times.
✓ Branch 5 taken 1577994 times.
 2240138 if (!table->is_placeholder() && table->table->found_next_number_field &&
10041
2/2
✓ Branch 0 taken 113848 times.
✓ Branch 1 taken 434907 times.
 548755 (table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE))
10042 113848 return true;
10043 }
10044
10045 745546 return false;
10046 }
10047
10048 /*
10049 checks if we have select tables in the table list and write tables
10050 with auto-increment column.
10051
10052 SYNOPSIS
10053 has_two_write_locked_tables_with_auto_increment_and_query_block
10054 tables Table list
10055
10056 RETURN VALUES
10057
10058 -true if the table list has at least one table with auto-increment column
10059 and at least one table to select from.
10060 -false otherwise
10061 */
10062
10063 849637 static bool has_write_table_with_auto_increment_and_query_block(
10064 TABLE_LIST *tables) {
10065 849637 bool has_query_block = false;
10066 849637 bool has_auto_increment_tables = has_write_table_with_auto_increment(tables);
10067
2/2
✓ Branch 0 taken 1219103 times.
✓ Branch 1 taken 435411 times.
 1654514 for (TABLE_LIST *table = tables; table; table = table->next_global) {
10068
4/4
✓ Branch 0 taken 1036796 times.
✓ Branch 1 taken 182407 times.
✓ Branch 2 taken 414696 times.
✓ Branch 3 taken 804436 times.
 2255828 if (!table->is_placeholder() &&
10069
2/2
✓ Branch 0 taken 414697 times.
✓ Branch 1 taken 622028 times.
 1036796 (table->lock_descriptor().type <= TL_READ_NO_INSERT)) {
10070 414696 has_query_block = true;
10071 414696 break;
10072 }
10073 }
10074
4/4
✓ Branch 0 taken 414697 times.
✓ Branch 1 taken 435410 times.
✓ Branch 2 taken 406 times.
✓ Branch 3 taken 414291 times.
 850107 return (has_query_block && has_auto_increment_tables);
10075 }
10076
10077 /*
10078 Tells if there is a table whose auto_increment column is a part
10079 of a compound primary key while is not the first column in
10080 the table definition.
10081
10082 @param tables Table list
10083
10084 @return true if the table exists, fais if does not.
10085 */
10086
10087 849637 static bool has_write_table_auto_increment_not_first_in_pk(TABLE_LIST *tables) {
10088
2/2
✓ Branch 0 taken 1681221 times.
✓ Branch 1 taken 850083 times.
 2531304 for (TABLE_LIST *table = tables; table; table = table->next_global) {
10089 /* we must do preliminary checks as table->table may be NULL */
10090
2/2
✓ Branch 0 taken 549003 times.
✓ Branch 1 taken 949671 times.
 3179895 if (!table->is_placeholder() && table->table->found_next_number_field &&
10091
6/6
✓ Branch 0 taken 1498674 times.
✓ Branch 1 taken 183003 times.
✓ Branch 2 taken 113870 times.
✓ Branch 3 taken 435135 times.
✓ Branch 4 taken 12 times.
✓ Branch 5 taken 1681667 times.
 3294221 (table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE) &&
10092
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 113858 times.
 113870 table->table->s->next_number_keypart != 0)
10093 12 return true;
10094 }
10095
10096 850083 return false;
10097 }
10098
10099 /**
10100 Checks if a table has a column with a non-deterministic DEFAULT expression.
10101 */
10102 10784 static bool has_nondeterministic_default(const TABLE *table) {
10103 21568 return std::any_of(
10104 10784 table->field, table->field + table->s->fields, [](const Field *field) {
10105
4/4
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 19415 times.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 14 times.
 19469 return field->m_default_val_expr != nullptr &&
10106 19469 field->m_default_val_expr->get_stmt_unsafe_flags() != 0;
10107 10784 });
10108 }
10109
10110 /**
10111 Checks if a TABLE_LIST contains a table that has been opened for writing, and
10112 that has a column with a non-deterministic DEFAULT expression.
10113 */
10114 9314 static bool has_write_table_with_nondeterministic_default(
10115 const TABLE_LIST *tables) {
10116
2/2
✓ Branch 0 taken 11222 times.
✓ Branch 1 taken 9301 times.
 20523 for (const TABLE_LIST *table = tables; table != nullptr;
10117 11209 table = table->next_global) {
10118 /* we must do preliminary checks as table->table may be NULL */
10119 11222 if (!table->is_placeholder() &&
10120
6/6
✓ Branch 0 taken 11165 times.
✓ Branch 1 taken 57 times.
✓ Branch 2 taken 10784 times.
✓ Branch 3 taken 381 times.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 11209 times.
 22006 table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE &&
10121
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 10771 times.
 10784 has_nondeterministic_default(table->table))
10122 13 return true;
10123 }
10124 9301 return false;
10125 }
10126
10127 /**
10128 Checks if we have reads from ACL tables in table list.
10129
10130 @param thd Current thread
10131 @param tl_list TABLE_LIST used by current command.
10132
10133 @returns true, if we statement is unsafe, otherwise false.
10134 */
10135 849573 static bool has_acl_table_read(THD *thd, const TABLE_LIST *tl_list) {
10136
2/2
✓ Branch 0 taken 1681163 times.
✓ Branch 1 taken 849243 times.
 2530406 for (const TABLE_LIST *tl = tl_list; tl != nullptr; tl = tl->next_global) {
10137
4/4
✓ Branch 0 taken 401446 times.
✓ Branch 1 taken 1280252 times.
✓ Branch 2 taken 868 times.
✓ Branch 3 taken 1680833 times.
 2082612 if (is_acl_table_in_non_LTM(tl, thd->locked_tables_mode) &&
10138
2/2
✓ Branch 0 taken 400575 times.
✓ Branch 1 taken 871 times.
 401446 (tl->lock_descriptor().type == TL_READ_DEFAULT ||
10139
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 400581 times.
 400575 tl->lock_descriptor().type == TL_READ_HIGH_PRIORITY))
10140 868 return true;
10141 }
10142 849243 return false;
10143 }
10144
10145 /*
10146 Function to check whether the table in query uses a fulltext parser
10147 plugin or not.
10148
10149 @param s - table share pointer.
10150
10151 @retval true - The table uses fulltext parser plugin.
10152 @retval false - Otherwise.
10153 */
10154 11257551 static bool inline fulltext_unsafe_set(TABLE_SHARE *s) {
10155
2/2
✓ Branch 0 taken 14153481 times.
✓ Branch 1 taken 11256322 times.
 25409803 for (unsigned int i = 0; i < s->keys; i++) {
10156
5/6
✓ Branch 0 taken 1229 times.
✓ Branch 1 taken 14152252 times.
✓ Branch 2 taken 1229 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1229 times.
✓ Branch 5 taken 14152252 times.
 14153481 if ((s->key_info[i].flags & HA_USES_PARSER) && s->keys_in_use.is_set(i))
10157 1229 return true;
10158 }
10159 11256322 return false;
10160 }
10161 #ifndef NDEBUG
10162 144 const char *get_locked_tables_mode_name(
10163 enum_locked_tables_mode locked_tables_mode) {
10164
2/5
✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 144 switch (locked_tables_mode) {
10165 139 case LTM_NONE:
10166 139 return "LTM_NONE";
10167 ✗ case LTM_LOCK_TABLES:
10168 ✗ return "LTM_LOCK_TABLES";
10169 5 case LTM_PRELOCKED:
10170 5 return "LTM_PRELOCKED";
10171 ✗ case LTM_PRELOCKED_UNDER_LOCK_TABLES:
10172 ✗ return "LTM_PRELOCKED_UNDER_LOCK_TABLES";
10173 ✗ default:
10174 ✗ return "Unknown table lock mode";
10175 }
10176 }
10177 #endif
10178
10179 /**
10180 Decide on logging format to use for the statement and issue errors
10181 or warnings as needed. The decision depends on the following
10182 parameters:
10183
10184 - The logging mode, i.e., the value of binlog_format. Can be
10185 statement, mixed, or row.
10186
10187 - The type of statement. There are three types of statements:
10188 "normal" safe statements; unsafe statements; and row injections.
10189 An unsafe statement is one that, if logged in statement format,
10190 might produce different results when replayed on the slave (e.g.,
10191 queries with a LIMIT clause). A row injection is either a BINLOG
10192 statement, or a row event executed by the slave's SQL thread.
10193
10194 - The capabilities of tables modified by the statement. The
10195 *capabilities vector* for a table is a set of flags associated
10196 with the table. Currently, it only includes two flags: *row
10197 capability flag* and *statement capability flag*.
10198
10199 The row capability flag is set if and only if the engine can
10200 handle row-based logging. The statement capability flag is set if
10201 and only if the table can handle statement-based logging.
10202
10203 Decision table for logging format
10204 ---------------------------------
10205
10206 The following table summarizes how the format and generated
10207 warning/error depends on the tables' capabilities, the statement
10208 type, and the current binlog_format.
10209
10210 Row capable N NNNNNNNNN YYYYYYYYY YYYYYYYYY
10211 Statement capable N YYYYYYYYY NNNNNNNNN YYYYYYYYY
10212
10213 Statement type * SSSUUUIII SSSUUUIII SSSUUUIII
10214
10215 binlog_format * SMRSMRSMR SMRSMRSMR SMRSMRSMR
10216
10217 Logged format - SS-S----- -RR-RR-RR SRRSRR-RR
10218 Warning/Error 1 --2732444 5--5--6-- ---7--6--
10219
10220 Legend
10221 ------
10222
10223 Row capable: N - Some table not row-capable, Y - All tables row-capable
10224 Stmt capable: N - Some table not stmt-capable, Y - All tables stmt-capable
10225 Statement type: (S)afe, (U)nsafe, or Row (I)njection
10226 binlog_format: (S)TATEMENT, (M)IXED, or (R)OW
10227 Logged format: (S)tatement or (R)ow
10228 Warning/Error: Warnings and error messages are as follows:
10229
10230 1. Error: Cannot execute statement: binlogging impossible since both
10231 row-incapable engines and statement-incapable engines are
10232 involved.
10233
10234 2. Error: Cannot execute statement: binlogging impossible since
10235 BINLOG_FORMAT = ROW and at least one table uses a storage engine
10236 limited to statement-logging.
10237
10238 3. Error: Cannot execute statement: binlogging of unsafe statement
10239 is impossible when storage engine is limited to statement-logging
10240 and BINLOG_FORMAT = MIXED.
10241
10242 4. Error: Cannot execute row injection: binlogging impossible since
10243 at least one table uses a storage engine limited to
10244 statement-logging.
10245
10246 5. Error: Cannot execute statement: binlogging impossible since
10247 BINLOG_FORMAT = STATEMENT and at least one table uses a storage
10248 engine limited to row-logging.
10249
10250 6. Error: Cannot execute row injection: binlogging impossible since
10251 BINLOG_FORMAT = STATEMENT.
10252
10253 7. Warning: Unsafe statement binlogged in statement format since
10254 BINLOG_FORMAT = STATEMENT.
10255
10256 In addition, we can produce the following error (not depending on
10257 the variables of the decision diagram):
10258
10259 8. Error: Cannot execute statement: binlogging impossible since more
10260 than one engine is involved and at least one engine is
10261 self-logging.
10262
10263 9. Error: Do not allow users to modify a gtid_executed table
10264 explicitly by a XA transaction.
10265
10266 For each error case above, the statement is prevented from being
10267 logged, we report an error, and roll back the statement. For
10268 warnings, we set the thd->binlog_flags variable: the warning will be
10269 printed only if the statement is successfully logged.
10270
10271 @see THD::binlog_query
10272
10273 @param[in] tables Tables involved in the query
10274
10275 @retval 0 No error; statement can be logged.
10276 @retval -1 One of the error conditions above applies (1, 2, 4, 5, 6 or 9).
10277 */
10278
10279 39143915 int THD::decide_logging_format(TABLE_LIST *tables) {
10280
1/2
✓ Branch 0 taken 39145514 times.
✗ Branch 1 not taken.
 39143915 DBUG_TRACE;
10281
6/10
✓ Branch 0 taken 39144920 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39145476 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 151 times.
✓ Branch 5 taken 39145325 times.
✓ Branch 6 taken 151 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 151 times.
✗ Branch 9 not taken.
 39145514 DBUG_PRINT("info", ("query: %s", query().str));
10282
5/8
✓ Branch 0 taken 39145456 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39145568 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 151 times.
✓ Branch 5 taken 39145417 times.
✓ Branch 6 taken 151 times.
✗ Branch 7 not taken.
 39145476 DBUG_PRINT("info", ("variables.binlog_format: %lu", variables.binlog_format));
10283
6/10
✓ Branch 0 taken 39145199 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39145563 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 151 times.
✓ Branch 5 taken 39145412 times.
✓ Branch 6 taken 151 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 151 times.
✗ Branch 9 not taken.
 39145568 DBUG_PRINT("info", ("lex->get_stmt_unsafe_flags(): 0x%x",
10284 lex->get_stmt_unsafe_flags()));
10285
10286 #if defined(ENABLED_DEBUG_SYNC)
10287
3/4
✓ Branch 0 taken 39145247 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39094770 times.
✓ Branch 3 taken 50477 times.
 39145563 if (!is_attachable_ro_transaction_active())
10288
3/4
✓ Branch 0 taken 36292777 times.
✓ Branch 1 taken 2801639 times.
✓ Branch 2 taken 36293471 times.
✗ Branch 3 not taken.
 39094770 DEBUG_SYNC(this, "begin_decide_logging_format");
10289 #endif
10290
10291 39145587 reset_binlog_local_stmt_filter();
10292
10293 /*
10294 We should not decide logging format if the binlog is closed or
10295 binlogging is off, or if the statement is filtered out from the
10296 binlog by filtering rules.
10297 */
10298
6/6
✓ Branch 0 taken 34115826 times.
✓ Branch 1 taken 5029587 times.
✓ Branch 2 taken 31950635 times.
✓ Branch 3 taken 2165191 times.
✓ Branch 4 taken 31948754 times.
✓ Branch 5 taken 7196632 times.
 71095995 if (mysql_bin_log.is_open() && (variables.option_bits & OPTION_BIN_LOG) &&
10299
2/2
✓ Branch 0 taken 1940007 times.
✓ Branch 1 taken 30010628 times.
 31950635 !(variables.binlog_format == BINLOG_FORMAT_STMT &&
10300
3/4
✓ Branch 0 taken 1939980 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1938090 times.
✓ Branch 3 taken 1890 times.
 1940007 !binlog_filter->db_ok(m_db.str))) {
10301 /*
10302 Compute one bit field with the union of all the engine
10303 capabilities, and one with the intersection of all the engine
10304 capabilities.
10305 */
10306 31948754 handler::Table_flags flags_write_some_set = 0;
10307 31948754 handler::Table_flags flags_access_some_set = 0;
10308 31948754 handler::Table_flags flags_write_all_set =
10309 HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE;
10310
10311 /*
10312 If different types of engines are about to be updated.
10313 For example: Innodb and Falcon; Innodb and MyIsam.
10314 */
10315 31948754 bool multi_write_engine = false;
10316 /*
10317 If different types of engines are about to be accessed
10318 and any of them is about to be updated. For example:
10319 Innodb and Falcon; Innodb and MyIsam.
10320 */
10321 31948754 bool multi_access_engine = false;
10322 /*
10323 Track if statement creates or drops a temporary table
10324 and log in ROW if it does.
10325 */
10326 31948754 bool is_create_drop_temp_table = false;
10327 /*
10328 Identifies if a table is changed.
10329 */
10330 31948754 bool is_write = false;
10331 /*
10332 A pointer to a previous table that was changed.
10333 */
10334 31948754 TABLE *prev_write_table = nullptr;
10335 /*
10336 A pointer to a previous table that was accessed.
10337 */
10338 31948754 TABLE *prev_access_table = nullptr;
10339 /*
10340 True if at least one table is transactional.
10341 */
10342 31948754 bool write_to_some_transactional_table = false;
10343 /*
10344 True if at least one table is non-transactional.
10345 */
10346 31948754 bool write_to_some_non_transactional_table = false;
10347 /*
10348 True if all non-transactional tables that has been updated
10349 are temporary.
10350 */
10351 31948754 bool write_all_non_transactional_are_tmp_tables = true;
10352 /**
10353 The number of tables used in the current statement,
10354 that should be replicated.
10355 */
10356 31948754 uint replicated_tables_count = 0;
10357 /**
10358 The number of tables written to in the current statement,
10359 that should not be replicated.
10360 A table should not be replicated when it is considered
10361 'local' to a MySQL instance.
10362 Currently, these tables are:
10363 - mysql.slow_log
10364 - mysql.general_log
10365 - mysql.slave_relay_log_info
10366 - mysql.slave_master_info
10367 - mysql.slave_worker_info
10368 - performance_schema.*
10369 - TODO: information_schema.*
10370 In practice, from this list, only performance_schema.* tables
10371 are written to by user queries.
10372 */
10373 31948754 uint non_replicated_tables_count = 0;
10374 /**
10375 Indicate whether we already reported a warning
10376 on modifying gtid_executed table.
10377 */
10378 31948754 int warned_gtid_executed_table = 0;
10379 #ifndef NDEBUG
10380 {
10381
6/10
✓ Branch 0 taken 31948746 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31948824 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 144 times.
✓ Branch 5 taken 31948680 times.
✓ Branch 6 taken 144 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 144 times.
✗ Branch 9 not taken.
 31948754 DBUG_PRINT("debug", ("prelocked_mode: %s",
10382 get_locked_tables_mode_name(locked_tables_mode)));
10383 }
10384 #endif
10385
10386
4/4
✓ Branch 0 taken 3715232 times.
✓ Branch 1 taken 28233592 times.
✓ Branch 2 taken 850136 times.
✓ Branch 3 taken 2865096 times.
 31948824 if (variables.binlog_format != BINLOG_FORMAT_ROW && tables) {
10387 /*
10388 DML statements that modify a table with an auto_increment column based
10389 on rows selected from a table are unsafe as the order in which the rows
10390 are fetched from the select tables cannot be determined and may differ
10391 on master and slave.
10392 */
10393
2/2
✓ Branch 0 taken 406 times.
✓ Branch 1 taken 849724 times.
 850136 if (has_write_table_with_auto_increment_and_query_block(tables))
10394
1/2
✓ Branch 0 taken 406 times.
✗ Branch 1 not taken.
 406 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_WRITE_AUTOINC_SELECT);
10395
10396
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 850100 times.
 850130 if (has_write_table_auto_increment_not_first_in_pk(tables))
10397
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
 12 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_AUTOINC_NOT_FIRST);
10398
10399 /*
10400 A query that modifies autoinc column in sub-statement can make the
10401 master and slave inconsistent.
10402 We can solve these problems in mixed mode by switching to binlogging
10403 if at least one updated table is used by sub-statement
10404 */
10405
6/6
✓ Branch 0 taken 9314 times.
✓ Branch 1 taken 840823 times.
✓ Branch 2 taken 289 times.
✓ Branch 3 taken 9031 times.
✓ Branch 4 taken 289 times.
✓ Branch 5 taken 849854 times.
 859432 if (lex->requires_prelocking() &&
10406 9314 has_write_table_with_auto_increment(lex->first_not_own_table()))
10407
1/2
✓ Branch 0 taken 289 times.
✗ Branch 1 not taken.
 289 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_AUTOINC_COLUMNS);
10408
10409 /*
10410 A query that modifies a table with a non-deterministic column default
10411 expression in a substatement, can make the master and the slave
10412 inconsistent. Switch to row logging in mixed mode, and raise a warning
10413 in statement mode.
10414 */
10415
4/4
✓ Branch 0 taken 9314 times.
✓ Branch 1 taken 840736 times.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 849890 times.
 859310 if (lex->requires_prelocking() &&
10416
3/4
✓ Branch 0 taken 9167 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 9154 times.
 9314 has_write_table_with_nondeterministic_default(
10417 9314 lex->first_not_own_table()))
10418
1/2
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
 13 lex->set_stmt_unsafe(
10419 LEX::BINLOG_STMT_UNSAFE_DEFAULT_EXPRESSION_IN_SUBSTATEMENT);
10420
10421 /*
10422 A DML or DDL statement is unsafe if it reads a ACL table while
10423 modifying the table, because SE skips acquiring row locks.
10424 Therefore rows seen by DML or DDL may not have same effect on slave.
10425
10426 We skip checking the same under lock tables mode, because we do
10427 not skip row locks on ACL table in this mode.
10428 */
10429
3/4
✓ Branch 0 taken 850105 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 868 times.
✓ Branch 3 taken 849237 times.
 849903 if (has_acl_table_read(this, tables)) {
10430
1/2
✓ Branch 0 taken 285 times.
✗ Branch 1 not taken.
 868 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_ACL_TABLE_READ_IN_DML_DDL);
10431 }
10432 }
10433
10434 /*
10435 Get the capabilities vector for all involved storage engines and
10436 mask out the flags for the binary log.
10437 */
10438
2/2
✓ Branch 0 taken 17315520 times.
✓ Branch 1 taken 31949366 times.
 49264886 for (TABLE_LIST *table = tables; table; table = table->next_global) {
10439
2/2
✓ Branch 0 taken 1186949 times.
✓ Branch 1 taken 16129547 times.
 17315520 if (table->is_placeholder()) {
10440 /*
10441 Detect if this is a CREATE TEMPORARY or DROP of a
10442 temporary table. This will be used later in determining whether to
10443 log in ROW or STMT if MIXED replication is being used.
10444 */
10445
6/6
✓ Branch 0 taken 1186945 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 825702 times.
✓ Branch 3 taken 361243 times.
✓ Branch 4 taken 8417 times.
✓ Branch 5 taken 1178533 times.
 2012652 if (!is_create_drop_temp_table && !table->table &&
10446
2/2
✓ Branch 0 taken 115724 times.
✓ Branch 1 taken 709978 times.
 825702 ((lex->sql_command == SQLCOM_CREATE_TABLE &&
10447
2/2
✓ Branch 0 taken 107311 times.
✓ Branch 1 taken 8413 times.
 115724 (lex->create_info->options & HA_LEX_CREATE_TMP_TABLE)) ||
10448
2/2
✓ Branch 0 taken 693219 times.
✓ Branch 1 taken 124070 times.
 817289 ((lex->sql_command == SQLCOM_DROP_TABLE ||
10449
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 693221 times.
 693219 lex->sql_command == SQLCOM_TRUNCATE) &&
10450
3/4
✓ Branch 0 taken 124069 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 124065 times.
 124068 find_temporary_table(this, table)))) {
10451 8417 is_create_drop_temp_table = true;
10452 }
10453 1186950 continue;
10454 }
10455 16129547 handler::Table_flags const flags = table->table->file->ha_table_flags();
10456
10457
5/8
✓ Branch 0 taken 16129211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16129565 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 373 times.
✓ Branch 5 taken 16129192 times.
✓ Branch 6 taken 373 times.
✗ Branch 7 not taken.
 16128383 DBUG_PRINT("info", ("table: %s; ha_table_flags: 0x%llx",
10458 table->table_name, flags));
10459
10460
2/2
✓ Branch 0 taken 895363 times.
✓ Branch 1 taken 15234202 times.
 16129565 if (table->table->no_replicate) {
10461
1/2
✓ Branch 0 taken 895363 times.
✗ Branch 1 not taken.
 895363 if (!warned_gtid_executed_table) {
10462 warned_gtid_executed_table =
10463
1/2
✓ Branch 0 taken 895363 times.
✗ Branch 1 not taken.
 895363 gtid_state->warn_or_err_on_modify_gtid_table(this, table);
10464 /*
10465 Do not allow users to modify the gtid_executed table
10466 explicitly by a XA transaction.
10467 */
10468
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 895360 times.
 895363 if (warned_gtid_executed_table == 2) return -1;
10469 }
10470 /*
10471 The statement uses a table that is not replicated.
10472 The following properties about the table:
10473 - persistent / transient
10474 - transactional / non transactional
10475 - temporary / permanent
10476 - read or write
10477 - multiple engines involved because of this table
10478 are not relevant, as this table is completely ignored.
10479 Because the statement uses a non replicated table,
10480 using STATEMENT format in the binlog is impossible.
10481 Either this statement will be discarded entirely,
10482 or it will be logged (possibly partially) in ROW format.
10483 */
10484
1/2
✓ Branch 0 taken 895360 times.
✗ Branch 1 not taken.
 895360 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_TABLE);
10485
10486
2/2
✓ Branch 0 taken 7924 times.
✓ Branch 1 taken 887436 times.
 895360 if (table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE) {
10487 7924 non_replicated_tables_count++;
10488 7924 continue;
10489 }
10490 }
10491
10492 16121638 replicated_tables_count++;
10493
10494 16121638 bool trans = table->table->file->has_transactions();
10495
10496
2/2
✓ Branch 0 taken 11256041 times.
✓ Branch 1 taken 4865628 times.
 16121584 if (table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE) {
10497 11256041 write_to_some_transactional_table =
10498
4/4
✓ Branch 0 taken 10936594 times.
✓ Branch 1 taken 319447 times.
✓ Branch 2 taken 10542167 times.
✓ Branch 3 taken 394427 times.
 11256041 write_to_some_transactional_table || trans;
10499
10500 11256041 write_to_some_non_transactional_table =
10501
4/4
✓ Branch 0 taken 11248782 times.
✓ Branch 1 taken 7259 times.
✓ Branch 2 taken 389925 times.
✓ Branch 3 taken 10858857 times.
 11256041 write_to_some_non_transactional_table || !trans;
10502
10503
2/2
✓ Branch 0 taken 326057 times.
✓ Branch 1 taken 10929984 times.
 11256041 if (prev_write_table &&
10504
2/2
✓ Branch 0 taken 3576 times.
✓ Branch 1 taken 322481 times.
 326057 prev_write_table->file->ht != table->table->file->ht)
10505 3576 multi_write_engine = true;
10506
10507
2/2
✓ Branch 0 taken 96763 times.
✓ Branch 1 taken 11159278 times.
 11256041 if (table->table->s->tmp_table)
10508
3/4
✓ Branch 0 taken 95258 times.
✓ Branch 1 taken 1505 times.
✓ Branch 2 taken 96763 times.
✗ Branch 3 not taken.
 96763 lex->set_stmt_accessed_table(
10509 trans ? LEX::STMT_WRITES_TEMP_TRANS_TABLE
10510 : LEX::STMT_WRITES_TEMP_NON_TRANS_TABLE);
10511 else
10512
3/4
✓ Branch 0 taken 10764505 times.
✓ Branch 1 taken 394773 times.
✓ Branch 2 taken 11159436 times.
✗ Branch 3 not taken.
 11159278 lex->set_stmt_accessed_table(trans
10513 ? LEX::STMT_WRITES_TRANS_TABLE
10514 : LEX::STMT_WRITES_NON_TRANS_TABLE);
10515
10516 /*
10517 Non-transactional updates are allowed when row binlog format is
10518 used and all non-transactional tables are temporary.
10519 Binlog format is checked on THD::is_dml_gtid_compatible() method.
10520 */
10521
2/2
✓ Branch 0 taken 395800 times.
✓ Branch 1 taken 10860399 times.
 11256199 if (!trans)
10522 395800 write_all_non_transactional_are_tmp_tables =
10523
2/2
✓ Branch 0 taken 390125 times.
✓ Branch 1 taken 5675 times.
 785925 write_all_non_transactional_are_tmp_tables &&
10524
2/2
✓ Branch 0 taken 1501 times.
✓ Branch 1 taken 388624 times.
 390125 table->table->s->tmp_table;
10525
10526 11256199 flags_write_all_set &= flags;
10527 11256199 flags_write_some_set |= flags;
10528 11256199 is_write = true;
10529
10530 11256199 prev_write_table = table->table;
10531
10532 /*
10533 It should be marked unsafe if a table which uses a fulltext parser
10534 plugin is modified. See also bug#48183.
10535 */
10536
1/2
✓ Branch 0 taken 11255016 times.
✗ Branch 1 not taken.
 11256199 if (!lex->is_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_FULLTEXT_PLUGIN)) {
10537
2/2
✓ Branch 0 taken 168 times.
✓ Branch 1 taken 11255327 times.
 11255016 if (fulltext_unsafe_set(table->table->s))
10538
1/2
✓ Branch 0 taken 168 times.
✗ Branch 1 not taken.
 168 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_FULLTEXT_PLUGIN);
10539 }
10540 /*
10541 INSERT...ON DUPLICATE KEY UPDATE on a table with more than one unique
10542 keys can be unsafe. Check for it if the flag is already not marked for
10543 the given statement.
10544 */
10545 11255455 if (!lex->is_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_INSERT_TWO_KEYS) &&
10546
6/6
✓ Branch 0 taken 11255850 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 10136982 times.
✓ Branch 3 taken 1118868 times.
✓ Branch 4 taken 82104 times.
✓ Branch 5 taken 11173749 times.
 21392835 lex->sql_command == SQLCOM_INSERT &&
10547
2/2
✓ Branch 0 taken 82104 times.
✓ Branch 1 taken 10054878 times.
 10136982 lex->duplicates == DUP_UPDATE) {
10548 82104 uint keys = table->table->s->keys, i = 0, unique_keys = 0;
10549 82104 for (KEY *keyinfo = table->table->s->key_info;
10550
4/4
✓ Branch 0 taken 85169 times.
✓ Branch 1 taken 82095 times.
✓ Branch 2 taken 85160 times.
✓ Branch 3 taken 9 times.
 167264 i < keys && unique_keys <= 1; i++, keyinfo++) {
10551
2/2
✓ Branch 0 taken 82383 times.
✓ Branch 1 taken 2777 times.
 85160 if (keyinfo->flags & HA_NOSAME) unique_keys++;
10552 }
10553
2/2
✓ Branch 0 taken 308 times.
✓ Branch 1 taken 81796 times.
 82104 if (unique_keys > 1)
10554
1/2
✓ Branch 0 taken 308 times.
✗ Branch 1 not taken.
 308 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_INSERT_TWO_KEYS);
10555 }
10556 }
10557
2/2
✓ Branch 0 taken 2684 times.
✓ Branch 1 taken 16118183 times.
 16121481 if (lex->get_using_match()) {
10558
2/2
✓ Branch 0 taken 1061 times.
✓ Branch 1 taken 1623 times.
 2684 if (fulltext_unsafe_set(table->table->s))
10559
1/2
✓ Branch 0 taken 1058 times.
✗ Branch 1 not taken.
 1061 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_FULLTEXT_PLUGIN);
10560 }
10561
10562 16120833 flags_access_some_set |= flags;
10563
10564
4/4
✓ Branch 0 taken 23904 times.
✓ Branch 1 taken 16096929 times.
✓ Branch 2 taken 16113197 times.
✓ Branch 3 taken 7636 times.
 16144737 if (lex->sql_command != SQLCOM_CREATE_TABLE ||
10565
1/2
✓ Branch 0 taken 23904 times.
✗ Branch 1 not taken.
 23904 (lex->sql_command == SQLCOM_CREATE_TABLE &&
10566
2/2
✓ Branch 0 taken 21544 times.
✓ Branch 1 taken 2360 times.
 23904 ((lex->create_info->options & HA_LEX_CREATE_TMP_TABLE) ||
10567
2/2
✓ Branch 0 taken 13732 times.
✓ Branch 1 taken 7812 times.
 21544 (table->lock_descriptor().type < TL_WRITE_ALLOW_WRITE)))) {
10568
2/2
✓ Branch 0 taken 111726 times.
✓ Branch 1 taken 16001471 times.
 16113197 if (table->table->s->tmp_table)
10569
3/4
✓ Branch 0 taken 106718 times.
✓ Branch 1 taken 5008 times.
✓ Branch 2 taken 111727 times.
✗ Branch 3 not taken.
 111726 lex->set_stmt_accessed_table(
10570 trans ? LEX::STMT_READS_TEMP_TRANS_TABLE
10571 : LEX::STMT_READS_TEMP_NON_TRANS_TABLE);
10572 else
10573
3/4
✓ Branch 0 taken 14945578 times.
✓ Branch 1 taken 1055893 times.
✓ Branch 2 taken 16002503 times.
✗ Branch 3 not taken.
 16001471 lex->set_stmt_accessed_table(trans ? LEX::STMT_READS_TRANS_TABLE
10574 : LEX::STMT_READS_NON_TRANS_TABLE);
10575 }
10576
10577
2/2
✓ Branch 0 taken 2713200 times.
✓ Branch 1 taken 13408666 times.
 16121866 if (prev_access_table &&
10578
2/2
✓ Branch 0 taken 12003 times.
✓ Branch 1 taken 2701197 times.
 2713200 prev_access_table->file->ht != table->table->file->ht)
10579 12003 multi_access_engine = true;
10580
10581 16121866 prev_access_table = table->table;
10582 }
10583
5/6
✓ Branch 0 taken 10930123 times.
✓ Branch 1 taken 21019243 times.
✓ Branch 2 taken 387849 times.
✓ Branch 3 taken 10542274 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 387849 times.
 31949366 assert(!is_write || write_to_some_transactional_table ||
10584 write_to_some_non_transactional_table);
10585 /*
10586 write_all_non_transactional_are_tmp_tables may be true if any
10587 non-transactional table was not updated, so we fix its value here.
10588 */
10589 31949366 write_all_non_transactional_are_tmp_tables =
10590
4/4
✓ Branch 0 taken 31559687 times.
✓ Branch 1 taken 389679 times.
✓ Branch 2 taken 1329 times.
✓ Branch 3 taken 31558358 times.
 31949366 write_all_non_transactional_are_tmp_tables &&
10591 write_to_some_non_transactional_table;
10592
10593
5/8
✓ Branch 0 taken 31948701 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31948744 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 148 times.
✓ Branch 5 taken 31948596 times.
✓ Branch 6 taken 148 times.
✗ Branch 7 not taken.
 31949366 DBUG_PRINT("info", ("flags_write_all_set: 0x%llx", flags_write_all_set));
10594
5/8
✓ Branch 0 taken 31948783 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31948851 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 148 times.
✓ Branch 5 taken 31948703 times.
✓ Branch 6 taken 148 times.
✗ Branch 7 not taken.
 31948744 DBUG_PRINT("info", ("flags_write_some_set: 0x%llx", flags_write_some_set));
10595
5/8
✓ Branch 0 taken 31948781 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31948899 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 148 times.
✓ Branch 5 taken 31948751 times.
✓ Branch 6 taken 148 times.
✗ Branch 7 not taken.
 31948851 DBUG_PRINT("info",
10596 ("flags_access_some_set: 0x%llx", flags_access_some_set));
10597
5/8
✓ Branch 0 taken 31948803 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31948881 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 148 times.
✓ Branch 5 taken 31948733 times.
✓ Branch 6 taken 148 times.
✗ Branch 7 not taken.
 31948899 DBUG_PRINT("info", ("multi_write_engine: %d", multi_write_engine));
10598
4/8
✓ Branch 0 taken 31948750 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31948885 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 148 times.
✓ Branch 5 taken 31948737 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 31948881 DBUG_PRINT("info", ("multi_access_engine: %d", multi_access_engine));
10599
10600 31948569 int error = 0;
10601 int unsafe_flags;
10602
10603 /*
10604 With transactional data dictionary, CREATE TABLE runs as one statement
10605 in a multi-statement transaction internally. Revert this for the
10606 purposes of determining mixed statement safety.
10607 */
10608
4/4
✓ Branch 0 taken 31814196 times.
✓ Branch 1 taken 134373 times.
✓ Branch 2 taken 11684900 times.
✓ Branch 3 taken 20129108 times.
 63762577 const bool multi_stmt_trans = lex->sql_command != SQLCOM_CREATE_TABLE &&
10609 31814196 in_multi_stmt_transaction_mode();
10610
1/2
✓ Branch 0 taken 31948757 times.
✗ Branch 1 not taken.
 31948381 bool trans_table = trans_has_updated_trans_table(this);
10611 31948757 bool binlog_direct = variables.binlog_direct_non_trans_update;
10612
10613
2/2
✓ Branch 0 taken 1347 times.
✓ Branch 1 taken 31947650 times.
 31948997 if (lex->is_mixed_stmt_unsafe(multi_stmt_trans, binlog_direct, trans_table,
10614
1/2
✓ Branch 0 taken 31948997 times.
✗ Branch 1 not taken.
 31948757 tx_isolation))
10615
1/2
✓ Branch 0 taken 1347 times.
✗ Branch 1 not taken.
 1347 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_MIXED_STATEMENT);
10616
8/8
✓ Branch 0 taken 11683690 times.
✓ Branch 1 taken 20263960 times.
✓ Branch 2 taken 10791198 times.
✓ Branch 3 taken 892492 times.
✓ Branch 4 taken 10753800 times.
✓ Branch 5 taken 37398 times.
✓ Branch 6 taken 1347 times.
✓ Branch 7 taken 31946303 times.
 42701450 else if (multi_stmt_trans && trans_table && !binlog_direct &&
10617
3/4
✓ Branch 0 taken 10753800 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1347 times.
✓ Branch 3 taken 10752453 times.
 10753800 lex->stmt_accessed_table(LEX::STMT_WRITES_NON_TRANS_TABLE))
10618
1/2
✓ Branch 0 taken 1347 times.
✗ Branch 1 not taken.
 1347 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_NONTRANS_AFTER_TRANS);
10619
10620 /*
10621 If more than one engine is involved in the statement and at
10622 least one is doing it's own logging (is *self-logging*), the
10623 statement cannot be logged atomically, so we generate an error
10624 rather than allowing the binlog to become corrupt.
10625 */
10626
3/4
✓ Branch 0 taken 3439 times.
✓ Branch 1 taken 31945558 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3439 times.
 31948997 if (multi_write_engine && (flags_write_some_set & HA_HAS_OWN_BINLOGGING))
10627 ✗ my_error((error = ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE),
10628 MYF(0));
10629
2/2
✓ Branch 0 taken 11188 times.
✓ Branch 1 taken 31937809 times.
 31948997 else if (multi_access_engine &&
10630
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11188 times.
 11188 flags_access_some_set & HA_HAS_OWN_BINLOGGING)
10631 ✗ lex->set_stmt_unsafe(
10632 LEX::BINLOG_STMT_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE);
10633
10634 /* XA is unsafe for statements */
10635
4/4
✓ Branch 0 taken 10929838 times.
✓ Branch 1 taken 21018338 times.
✓ Branch 2 taken 1031 times.
✓ Branch 3 taken 31947088 times.
 42877957 if (is_write &&
10636
2/2
✓ Branch 0 taken 1031 times.
✓ Branch 1 taken 10928750 times.
 10929838 !get_transaction()->xid_state()->has_state(XID_STATE::XA_NOTR))
10637
1/2
✓ Branch 0 taken 1031 times.
✗ Branch 1 not taken.
 1031 lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_XA);
10638
10639
3/4
✓ Branch 0 taken 31948265 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6030 times.
✓ Branch 3 taken 31942235 times.
 31948119 DBUG_EXECUTE_IF("make_stmt_only_engines",
10640 { flags_write_all_set = HA_BINLOG_STMT_CAPABLE; };);
10641
10642 /* both statement-only and row-only engines involved */
10643
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31948265 times.
 31948265 if ((flags_write_all_set &
10644 (HA_BINLOG_STMT_CAPABLE | HA_BINLOG_ROW_CAPABLE)) == 0) {
10645 /*
10646 1. Error: Binary logging impossible since both row-incapable
10647 engines and statement-incapable engines are involved
10648 */
10649 ✗ my_error((error = ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE), MYF(0));
10650 }
10651 /* statement-only engines involved */
10652
2/2
✓ Branch 0 taken 6036 times.
✓ Branch 1 taken 31942229 times.
 31948265 else if ((flags_write_all_set & HA_BINLOG_ROW_CAPABLE) == 0) {
10653
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6036 times.
 6036 if (lex->is_stmt_row_injection()) {
10654 /*
10655 4. Error: Cannot execute row injection since table uses
10656 storage engine limited to statement-logging
10657 */
10658 ✗ my_error((error = ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE), MYF(0));
10659
4/4
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6033 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 6033 times.
 6039 } else if (variables.binlog_format == BINLOG_FORMAT_ROW &&
10660
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 sqlcom_can_generate_row_events(this->lex->sql_command)) {
10661 /*
10662 2. Error: Cannot modify table that uses a storage engine
10663 limited to statement-logging when BINLOG_FORMAT = ROW
10664 */
10665
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 my_error((error = ER_BINLOG_ROW_MODE_AND_STMT_ENGINE), MYF(0));
10666
4/4
✓ Branch 0 taken 581 times.
✓ Branch 1 taken 5452 times.
✓ Branch 2 taken 177 times.
✓ Branch 3 taken 5856 times.
 6614 } else if (variables.binlog_format == BINLOG_FORMAT_MIXED &&
10667
3/4
✓ Branch 0 taken 581 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 177 times.
✓ Branch 3 taken 404 times.
 581 ((unsafe_flags = lex->get_stmt_unsafe_flags()) != 0)) {
10668 /*
10669 3. Error: Cannot execute statement: binlogging of unsafe
10670 statement is impossible when storage engine is limited to
10671 statement-logging and BINLOG_FORMAT = MIXED.
10672 */
10673
2/2
✓ Branch 0 taken 4602 times.
✓ Branch 1 taken 177 times.
 4779 for (int unsafe_type = 0; unsafe_type < LEX::BINLOG_STMT_UNSAFE_COUNT;
10674 unsafe_type++)
10675
2/2
✓ Branch 0 taken 201 times.
✓ Branch 1 taken 4401 times.
 4602 if (unsafe_flags & (1 << unsafe_type))
10676
1/2
✓ Branch 0 taken 201 times.
✗ Branch 1 not taken.
 201 my_error(
10677 (error = ER_BINLOG_UNSAFE_AND_STMT_ENGINE), MYF(0),
10678
1/2
✓ Branch 0 taken 201 times.
✗ Branch 1 not taken.
 201 ER_THD_NONCONST(current_thd,
10679
1/2
✓ Branch 0 taken 201 times.
✗ Branch 1 not taken.
 201 LEX::binlog_stmt_unsafe_errcode[unsafe_type]));
10680
4/4
✓ Branch 0 taken 342 times.
✓ Branch 1 taken 5514 times.
✓ Branch 2 taken 188 times.
✓ Branch 3 taken 5668 times.
 6198 } else if (is_write &&
10681
3/4
✓ Branch 0 taken 342 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 188 times.
✓ Branch 3 taken 154 times.
 342 ((unsafe_flags = lex->get_stmt_unsafe_flags()) != 0)) {
10682 /*
10683 7. Warning: Unsafe statement logged as statement due to
10684 binlog_format = STATEMENT
10685 */
10686 188 binlog_unsafe_warning_flags |= unsafe_flags;
10687
3/12
✓ Branch 0 taken 188 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 188 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 188 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
 188 DBUG_PRINT("info", ("Scheduling warning to be issued by "
10688 "binlog_query: '%s'",
10689 ER_THD(current_thd, ER_BINLOG_UNSAFE_STATEMENT)));
10690
3/8
✓ Branch 0 taken 188 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 188 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 188 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 188 DBUG_PRINT("info", ("binlog_unsafe_warning_flags: 0x%x",
10691 binlog_unsafe_warning_flags));
10692 }
10693 /* log in statement format! */
10694 }
10695 /* no statement-only engines */
10696 else {
10697 /* binlog_format = STATEMENT */
10698
2/2
✓ Branch 0 taken 1932354 times.
✓ Branch 1 taken 30009875 times.
 31942229 if (variables.binlog_format == BINLOG_FORMAT_STMT) {
10699
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1932548 times.
 1932354 if (lex->is_stmt_row_injection()) {
10700 /*
10701 6. Error: Cannot execute row injection since
10702 BINLOG_FORMAT = STATEMENT
10703 */
10704
0/2
✗ Branch 0 not taken.
✗ Branch 1 not taken.
 1 my_error((error = ER_BINLOG_ROW_INJECTION_AND_STMT_MODE), MYF(0));
10705
3/4
✓ Branch 0 taken 864 times.
✓ Branch 1 taken 1931684 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1932548 times.
 1933412 } else if ((flags_write_all_set & HA_BINLOG_STMT_CAPABLE) == 0 &&
10706
2/4
✓ Branch 0 taken 864 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 864 times.
 864 sqlcom_can_generate_row_events(this->lex->sql_command)) {
10707 /*
10708 5. Error: Cannot modify table that uses a storage engine
10709 limited to row-logging when binlog_format = STATEMENT
10710 */
10711 ✗ my_error((error = ER_BINLOG_STMT_MODE_AND_ROW_ENGINE), MYF(0), "");
10712
4/4
✓ Branch 0 taken 192894 times.
✓ Branch 1 taken 1739654 times.
✓ Branch 2 taken 13053 times.
✓ Branch 3 taken 1919581 times.
 2125528 } else if (is_write &&
10713
3/4
✓ Branch 0 taken 192980 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13053 times.
✓ Branch 3 taken 179927 times.
 192894 (unsafe_flags = lex->get_stmt_unsafe_flags()) != 0) {
10714 /*
10715 7. Warning: Unsafe statement logged as statement due to
10716 binlog_format = STATEMENT
10717 */
10718 13053 binlog_unsafe_warning_flags |= unsafe_flags;
10719
3/12
✓ Branch 0 taken 13053 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13053 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 13053 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
 13053 DBUG_PRINT("info", ("Scheduling warning to be issued by "
10720 "binlog_query: '%s'",
10721 ER_THD(current_thd, ER_BINLOG_UNSAFE_STATEMENT)));
10722
3/8
✓ Branch 0 taken 13053 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13053 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 13053 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 13053 DBUG_PRINT("info", ("binlog_unsafe_warning_flags: 0x%x",
10723 binlog_unsafe_warning_flags));
10724 }
10725 /* log in statement format! */
10726 }
10727 /* No statement-only engines and binlog_format != STATEMENT.
10728 I.e., nothing prevents us from row logging if needed. */
10729 else {
10730
5/6
✓ Branch 0 taken 30009670 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27129138 times.
✓ Branch 3 taken 286096 times.
✓ Branch 4 taken 27129078 times.
✓ Branch 5 taken 364 times.
 84554492 if (lex->is_stmt_unsafe() || lex->is_stmt_row_injection() ||
10731 27129138 lex->is_stmt_unsafe_with_mixed_mode() ||
10732
2/2
✓ Branch 0 taken 27127061 times.
✓ Branch 1 taken 2017 times.
 27129078 (flags_write_all_set & HA_BINLOG_STMT_CAPABLE) == 0 ||
10733
3/4
✓ Branch 0 taken 27127226 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27024656 times.
✓ Branch 3 taken 102570 times.
 27127061 lex->stmt_accessed_table(LEX::STMT_READS_TEMP_TRANS_TABLE) ||
10734
9/10
✓ Branch 0 taken 27415175 times.
✓ Branch 1 taken 2594495 times.
✓ Branch 2 taken 27024678 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 27021370 times.
✓ Branch 5 taken 3308 times.
✓ Branch 6 taken 6612 times.
✓ Branch 7 taken 27014758 times.
✓ Branch 8 taken 2995466 times.
✓ Branch 9 taken 27014754 times.
 57425373 lex->stmt_accessed_table(LEX::STMT_READS_TEMP_NON_TRANS_TABLE) ||
10735 is_create_drop_temp_table) {
10736 #ifndef NDEBUG
10737
1/2
✓ Branch 0 taken 2995523 times.
✗ Branch 1 not taken.
 2995466 int flags = lex->get_stmt_unsafe_flags();
10738
5/8
✓ Branch 0 taken 2995507 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2995473 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2995468 times.
✓ Branch 6 taken 13 times.
✗ Branch 7 not taken.
 2995523 DBUG_PRINT("info", ("setting row format for unsafe statement"));
10739
2/2
✓ Branch 0 taken 77878359 times.
✓ Branch 1 taken 2997411 times.
 80875770 for (int i = 0; i < Query_tables_list::BINLOG_STMT_UNSAFE_COUNT;
10740 i++) {
10741
2/2
✓ Branch 0 taken 2625309 times.
✓ Branch 1 taken 75253050 times.
 77878359 if (flags & (1 << i))
10742
7/12
✓ Branch 0 taken 2625330 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2625306 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2625301 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 5 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1938 times.
✗ Branch 11 not taken.
 2625309 DBUG_PRINT(
10743 "info",
10744 ("unsafe reason: %s",
10745 ER_THD_NONCONST(
10746 current_thd,
10747 Query_tables_list::binlog_stmt_unsafe_errcode[i])));
10748 }
10749
5/8
✓ Branch 0 taken 2995520 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2995518 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2995513 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
 2997411 DBUG_PRINT("info",
10750 ("is_row_injection=%d", lex->is_stmt_row_injection()));
10751
5/8
✓ Branch 0 taken 2995517 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2995519 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2995514 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
 2995518 DBUG_PRINT("info", ("stmt_capable=%llu",
10752 (flags_write_all_set & HA_BINLOG_STMT_CAPABLE)));
10753
5/8
✓ Branch 0 taken 2995445 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2995508 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2995503 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
 2995519 DBUG_PRINT("info", ("lex->is_stmt_unsafe_with_mixed_mode = %d",
10754 lex->is_stmt_unsafe_with_mixed_mode()));
10755 #endif
10756 /* log in row format! */
10757
1/2
✓ Branch 0 taken 2994263 times.
✗ Branch 1 not taken.
 2995508 set_current_stmt_binlog_format_row_if_mixed();
10758 }
10759 }
10760 }
10761
10762
2/2
✓ Branch 0 taken 7924 times.
✓ Branch 1 taken 31939763 times.
 31947687 if (non_replicated_tables_count > 0) {
10763
4/4
✓ Branch 0 taken 138 times.
✓ Branch 1 taken 7786 times.
✓ Branch 2 taken 118 times.
✓ Branch 3 taken 20 times.
 7924 if ((replicated_tables_count == 0) || !is_write) {
10764
3/8
✓ Branch 0 taken 7904 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7904 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 7904 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 7904 DBUG_PRINT("info",
10765 ("decision: no logging, no replicated table affected"));
10766 7904 set_binlog_local_stmt_filter();
10767 } else {
10768
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 12 times.
 20 if (!is_current_stmt_binlog_format_row()) {
10769
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 my_error((error = ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES), MYF(0));
10770 } else {
10771 12 clear_binlog_local_stmt_filter();
10772 }
10773 }
10774 } else {
10775 31939763 clear_binlog_local_stmt_filter();
10776 }
10777
10778
4/4
✓ Branch 0 taken 31947201 times.
✓ Branch 1 taken 199 times.
✓ Branch 2 taken 396 times.
✓ Branch 3 taken 31948505 times.
 63896102 if (!error &&
10779
3/4
✓ Branch 0 taken 31948702 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 396 times.
✓ Branch 3 taken 31948306 times.
 31947201 !is_dml_gtid_compatible(write_to_some_transactional_table,
10780 write_to_some_non_transactional_table,
10781 write_all_non_transactional_are_tmp_tables))
10782 396 error = 1;
10783
10784
2/2
✓ Branch 0 taken 584 times.
✓ Branch 1 taken 31948317 times.
 31948901 if (error) {
10785
3/8
✓ Branch 0 taken 584 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 584 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 584 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 584 DBUG_PRINT("info", ("decision: no logging since an error was generated"));
10786 584 return -1;
10787 }
10788
10789
2/2
✓ Branch 0 taken 10929082 times.
✓ Branch 1 taken 21019235 times.
 31948317 if (is_write &&
10790
2/2
✓ Branch 0 taken 10642708 times.
✓ Branch 1 taken 286374 times.
 10929082 lex->sql_command != SQLCOM_END /* rows-event applying by slave */) {
10791 /*
10792 Master side of DML in the STMT format events parallelization.
10793 All involving table db:s are stored in a abc-ordered name list.
10794 In case the number of databases exceeds MAX_DBS_IN_EVENT_MTS maximum
10795 the list gathering breaks since it won't be sent to the slave.
10796 */
10797
2/2
✓ Branch 0 taken 11020675 times.
✓ Branch 1 taken 10642155 times.
 21662830 for (TABLE_LIST *table = tables; table; table = table->next_global) {
10798
2/2
✓ Branch 0 taken 11976 times.
✓ Branch 1 taken 11009521 times.
 11020675 if (table->is_placeholder()) continue;
10799
10800
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11009521 times.
 11009521 assert(table->table);
10801
10802
2/2
✓ Branch 0 taken 995 times.
✓ Branch 1 taken 11007440 times.
 11009521 if (table->table->s->is_referenced_by_foreign_key()) {
10803 /*
10804 FK-referenced dbs can't be gathered currently. The following
10805 event will be marked for sequential execution on slave.
10806 */
10807 995 binlog_accessed_db_names = nullptr;
10808
1/2
✓ Branch 0 taken 995 times.
✗ Branch 1 not taken.
 995 add_to_binlog_accessed_dbs("");
10809 995 break;
10810 }
10811
2/2
✓ Branch 0 taken 589996 times.
✓ Branch 1 taken 10417956 times.
 11007440 if (!is_current_stmt_binlog_format_row())
10812
1/2
✓ Branch 0 taken 590190 times.
✗ Branch 1 not taken.
 589996 add_to_binlog_accessed_dbs(table->db);
10813 }
10814 }
10815
7/10
✓ Branch 0 taken 31947545 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31948073 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 148 times.
✓ Branch 5 taken 31947925 times.
✓ Branch 6 taken 114 times.
✓ Branch 7 taken 34 times.
✓ Branch 8 taken 148 times.
✗ Branch 9 not taken.
 31948759 DBUG_PRINT("info",
10816 ("decision: logging in %s format",
10817 is_current_stmt_binlog_format_row() ? "ROW" : "STATEMENT"));
10818
10819
2/2
✓ Branch 0 taken 28233244 times.
✓ Branch 1 taken 3714829 times.
 31948073 if (variables.binlog_format == BINLOG_FORMAT_ROW &&
10820
2/2
✓ Branch 0 taken 27862964 times.
✓ Branch 1 taken 370280 times.
 28233244 (lex->sql_command == SQLCOM_UPDATE ||
10821
2/2
✓ Branch 0 taken 27860986 times.
✓ Branch 1 taken 1978 times.
 27862964 lex->sql_command == SQLCOM_UPDATE_MULTI ||
10822
2/2
✓ Branch 0 taken 27806574 times.
✓ Branch 1 taken 54412 times.
 27860986 lex->sql_command == SQLCOM_DELETE ||
10823
2/2
✓ Branch 0 taken 677 times.
✓ Branch 1 taken 27805897 times.
 27806574 lex->sql_command == SQLCOM_DELETE_MULTI)) {
10824 427347 String table_names;
10825 /*
10826 Generate a warning for UPDATE/DELETE statements that modify a
10827 BLACKHOLE table, as row events are not logged in row format.
10828 */
10829
2/2
✓ Branch 0 taken 443649 times.
✓ Branch 1 taken 427507 times.
 871156 for (TABLE_LIST *table = tables; table; table = table->next_global) {
10830
2/2
✓ Branch 0 taken 8400 times.
✓ Branch 1 taken 435279 times.
 443649 if (table->is_placeholder()) continue;
10831
4/4
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 435265 times.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 435265 times.
 435293 if (table->table->file->ht->db_type == DB_TYPE_BLACKHOLE_DB &&
10832
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE) {
10833
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 table_names.append(table->table_name);
10834
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 table_names.append(",");
10835 }
10836 }
10837
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 427429 times.
 427507 if (!table_names.is_empty()) {
10838
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 6 times.
 22 bool is_update = (lex->sql_command == SQLCOM_UPDATE ||
10839
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 7 times.
 8 lex->sql_command == SQLCOM_UPDATE_MULTI);
10840 /*
10841 Replace the last ',' with '.' for table_names
10842 */
10843
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 table_names.replace(table_names.length() - 1, 1, ".", 1);
10844
5/8
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 7 times.
✓ Branch 4 taken 14 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 14 times.
✗ Branch 7 not taken.
 14 push_warning_printf(
10845 this, Sql_condition::SL_WARNING, WARN_ON_BLOCKHOLE_IN_RBR,
10846 ER_THD(this, WARN_ON_BLOCKHOLE_IN_RBR),
10847 is_update ? "UPDATE" : "DELETE", table_names.c_ptr());
10848 }
10849 427443 }
10850 } else {
10851
6/10
✓ Branch 0 taken 7196583 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7196661 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 7196658 times.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
 7196632 DBUG_PRINT(
10852 "info",
10853 ("decision: no logging since "
10854 "mysql_bin_log.is_open() = %d "
10855 "and (options & OPTION_BIN_LOG) = 0x%llx "
10856 "and binlog_format = %lu "
10857 "and binlog_filter->db_ok(db) = %d",
10858 mysql_bin_log.is_open(), (variables.option_bits & OPTION_BIN_LOG),
10859 variables.binlog_format, binlog_filter->db_ok(m_db.str)));
10860
10861
2/2
✓ Branch 0 taken 6447066 times.
✓ Branch 1 taken 7196678 times.
 13643744 for (TABLE_LIST *table = tables; table; table = table->next_global) {
10862
6/6
✓ Branch 0 taken 5852394 times.
✓ Branch 1 taken 594684 times.
✓ Branch 2 taken 1048355 times.
✓ Branch 3 taken 4804039 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 6447084 times.
 7495428 if (!table->is_placeholder() && table->table->no_replicate &&
10863
3/4
✓ Branch 0 taken 1048362 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1048361 times.
 1048355 gtid_state->warn_or_err_on_modify_gtid_table(this, table))
10864 1 break;
10865 }
10866 }
10867
10868 #if defined(ENABLED_DEBUG_SYNC)
10869
3/4
✓ Branch 0 taken 39143620 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39093413 times.
✓ Branch 3 taken 50207 times.
 39144846 if (!is_attachable_ro_transaction_active())
10870
3/4
✓ Branch 0 taken 36291635 times.
✓ Branch 1 taken 2801590 times.
✓ Branch 2 taken 36293225 times.
✗ Branch 3 not taken.
 39093413 DEBUG_SYNC(this, "end_decide_logging_format");
10871 #endif
10872
10873 39145022 return 0;
10874 39145609 }
10875
10876 /**
10877 Given that a possible violation of gtid consistency has happened,
10878 checks if gtid-inconsistencies are forbidden by the current value of
10879 ENFORCE_GTID_CONSISTENCY and GTID_MODE. If forbidden, generates
10880 error or warning accordingly.
10881
10882 @param thd The thread that has issued the GTID-violating statement.
10883
10884 @param error_code The error code to use, if error or warning is to
10885 be generated.
10886
10887 @param log_error_code The error code to use, if error message is to
10888 be logged.
10889
10890 @retval false Error was generated.
10891 @retval true No error was generated (possibly a warning was generated).
10892 */
10893 6943 static bool handle_gtid_consistency_violation(THD *thd, int error_code,
10894 int log_error_code) {
10895
1/2
✓ Branch 0 taken 6943 times.
✗ Branch 1 not taken.
 6943 DBUG_TRACE;
10896
10897 6943 enum_gtid_type gtid_next_type = thd->variables.gtid_next.type;
10898
1/2
✓ Branch 0 taken 6943 times.
✗ Branch 1 not taken.
 6943 global_sid_lock->rdlock();
10899 enum_gtid_consistency_mode gtid_consistency_mode =
10900
1/2
✓ Branch 0 taken 6943 times.
✗ Branch 1 not taken.
 6943 get_gtid_consistency_mode();
10901
1/2
✓ Branch 0 taken 6943 times.
✗ Branch 1 not taken.
 6943 auto gtid_mode = global_gtid_mode.get();
10902
10903
7/12
✓ Branch 0 taken 6943 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6943 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 6937 times.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
 6943 DBUG_PRINT("info", ("gtid_next.type=%d gtid_mode=%s "
10904 "gtid_consistency_mode=%d error=%d query=%s",
10905 gtid_next_type, Gtid_mode::to_string(gtid_mode),
10906 gtid_consistency_mode, error_code, thd->query().str));
10907
10908 /*
10909 GTID violations should generate error if:
10910 - GTID_MODE=ON or ON_PERMISSIVE and GTID_NEXT='AUTOMATIC' (since the
10911 transaction is expected to commit using a GTID), or
10912 - GTID_NEXT='UUID:NUMBER' (since the transaction is expected to
10913 commit usinga GTID), or
10914 - ENFORCE_GTID_CONSISTENCY=ON.
10915 */
10916
2/2
✓ Branch 0 taken 5602 times.
✓ Branch 1 taken 1341 times.
 6943 if ((gtid_next_type == AUTOMATIC_GTID &&
10917
4/4
✓ Branch 0 taken 5261 times.
✓ Branch 1 taken 341 times.
✓ Branch 2 taken 6312 times.
✓ Branch 3 taken 290 times.
 6943 gtid_mode >= Gtid_mode::ON_PERMISSIVE) ||
10918
2/2
✓ Branch 0 taken 280 times.
✓ Branch 1 taken 6032 times.
 6312 gtid_next_type == ASSIGNED_GTID ||
10919 gtid_consistency_mode == GTID_CONSISTENCY_MODE_ON) {
10920
1/2
✓ Branch 0 taken 911 times.
✗ Branch 1 not taken.
 911 global_sid_lock->unlock();
10921
1/2
✓ Branch 0 taken 911 times.
✗ Branch 1 not taken.
 911 my_error(error_code, MYF(0));
10922 911 return false;
10923 } else {
10924 /*
10925 If we are not generating an error, we must increase the counter
10926 of GTID-violating transactions. This will prevent a concurrent
10927 client from executing a SET GTID_MODE or SET
10928 ENFORCE_GTID_CONSISTENCY statement that would be incompatible
10929 with this transaction.
10930
10931 If the transaction had already been accounted as a gtid violating
10932 transaction, then don't increment the counters, just issue the
10933 warning below. This prevents calling
10934 begin_automatic_gtid_violating_transaction or
10935 begin_anonymous_gtid_violating_transaction multiple times for the
10936 same transaction, which would make the counter go out of sync.
10937 */
10938
2/2
✓ Branch 0 taken 4665 times.
✓ Branch 1 taken 1367 times.
 6032 if (!thd->has_gtid_consistency_violation) {
10939
2/2
✓ Branch 0 taken 3878 times.
✓ Branch 1 taken 787 times.
 4665 if (gtid_next_type == AUTOMATIC_GTID)
10940
1/2
✓ Branch 0 taken 3878 times.
✗ Branch 1 not taken.
 3878 gtid_state->begin_automatic_gtid_violating_transaction();
10941 else {
10942
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 787 times.
 787 assert(gtid_next_type == ANONYMOUS_GTID);
10943
1/2
✓ Branch 0 taken 787 times.
✗ Branch 1 not taken.
 787 gtid_state->begin_anonymous_gtid_violating_transaction();
10944 }
10945
10946 /*
10947 If a transaction generates multiple GTID violation conditions,
10948 it must still only update the counters once. Hence we use
10949 this per-thread flag to keep track of whether the thread has a
10950 consistency or not. This function must only be called if the
10951 transaction does not already have a GTID violation.
10952 */
10953 4665 thd->has_gtid_consistency_violation = true;
10954 }
10955
10956
1/2
✓ Branch 0 taken 6032 times.
✗ Branch 1 not taken.
 6032 global_sid_lock->unlock();
10957
10958 // Generate warning if ENFORCE_GTID_CONSISTENCY = WARN.
10959
2/2
✓ Branch 0 taken 288 times.
✓ Branch 1 taken 5744 times.
 6032 if (gtid_consistency_mode == GTID_CONSISTENCY_MODE_WARN) {
10960 // Need to print to log so that replication admin knows when users
10961 // have adjusted their workloads.
10962
8/16
✓ Branch 0 taken 288 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 288 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 288 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 288 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 288 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 288 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 288 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 288 times.
✗ Branch 15 not taken.
 288 LogErr(WARNING_LEVEL, log_error_code);
10963 // Need to print to client so that users can adjust their workload.
10964
2/4
✓ Branch 0 taken 288 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 288 times.
✗ Branch 3 not taken.
 288 push_warning(thd, Sql_condition::SL_WARNING, error_code,
10965 ER_THD_NONCONST(thd, error_code));
10966 }
10967 6032 return true;
10968 }
10969 6943 }
10970
10971 29133658 bool THD::is_ddl_gtid_compatible() {
10972
1/2
✓ Branch 0 taken 29134417 times.
✗ Branch 1 not taken.
 29133658 DBUG_TRACE;
10973
10974 29134417 bool is_binlog_open{mysql_bin_log.is_open()};
10975 29134225 bool is_binlog_enabled_for_session{(variables.option_bits & OPTION_BIN_LOG) !=
10976 0};
10977
4/8
✓ Branch 0 taken 29134347 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29134481 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 191 times.
✓ Branch 5 taken 29134290 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 29134225 DBUG_PRINT("info", ("is_binlog_open:%d is_binlog_enabled_for_session:%d",
10978 is_binlog_open, is_binlog_enabled_for_session));
10979 // If we are not going to log, then no problem, we can execute any
10980 // statement.
10981
4/4
✓ Branch 0 taken 24031647 times.
✓ Branch 1 taken 5102476 times.
✓ Branch 2 taken 1103250 times.
✓ Branch 3 taken 22928397 times.
 29134123 if (!is_binlog_open || !is_binlog_enabled_for_session) return true;
10982
10983 22928397 bool is_create_table{lex->sql_command == SQLCOM_CREATE_TABLE};
10984 22928397 bool is_create_temporary_table{false};
10985 22928397 bool is_create_table_select{false};
10986 22928397 bool is_create_table_atomic{false};
10987
2/2
✓ Branch 0 taken 127060 times.
✓ Branch 1 taken 22801337 times.
 22928397 if (is_create_table) {
10988 // Check this conditionally, since create_info and/or query_block
10989 // may be uninitialized if sql_command!=SQLCOM_CREATE_TABLE.
10990 127060 is_create_temporary_table =
10991 127060 (lex->create_info->options & HA_LEX_CREATE_TMP_TABLE);
10992
2/2
✓ Branch 0 taken 117643 times.
✓ Branch 1 taken 9417 times.
 127060 if (!is_create_temporary_table)
10993
1/2
✓ Branch 0 taken 117643 times.
✗ Branch 1 not taken.
 117643 is_create_table_select = !lex->query_block->field_list_is_empty();
10994 127060 is_create_table_atomic =
10995
1/2
✓ Branch 0 taken 127060 times.
✗ Branch 1 not taken.
 127060 get_default_handlerton(this, lex->create_info->db_type)->flags &
10996 HTON_SUPPORTS_ATOMIC_DDL;
10997 }
10998
10999 22928397 bool is_drop_table{lex->sql_command == SQLCOM_DROP_TABLE};
11000 22928397 bool is_drop_temporary_table{false};
11001
2/2
✓ Branch 0 taken 100015 times.
✓ Branch 1 taken 22828382 times.
 22928397 if (is_drop_table) is_drop_temporary_table = lex->drop_temporary;
11002
11003 22928397 bool is_in_transaction{in_multi_stmt_transaction_mode()};
11004
11005 22928299 bool is_in_sub_statement{in_sub_stmt != 0};
11006
11007 22928299 bool is_binlog_format_statement{variables.binlog_format ==
11008 BINLOG_FORMAT_STMT};
11009
11010
5/8
✓ Branch 0 taken 22928665 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22928536 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 189 times.
✓ Branch 5 taken 22928347 times.
✓ Branch 6 taken 189 times.
✗ Branch 7 not taken.
 22928299 DBUG_PRINT("info", ("is_create_table:%d is_create_temporary_table:%d "
11011 "is_create_table_select:%d is_create_table_atomic:%d "
11012 "is_drop_table:%d is_drop_temporary_table:%d "
11013 "is_in_transaction:%d is_in_sub_statement:%d "
11014 "is_binlog_format_statement:%d",
11015 is_create_table, is_create_temporary_table,
11016 is_create_table_select, is_create_table_atomic,
11017 is_drop_table, is_drop_temporary_table, is_in_transaction,
11018 is_in_sub_statement, is_binlog_format_statement));
11019
11020
3/4
✓ Branch 0 taken 8365 times.
✓ Branch 1 taken 22920171 times.
✓ Branch 2 taken 8365 times.
✗ Branch 3 not taken.
 22928536 if (is_create_table_select && !is_create_temporary_table &&
11021
2/2
✓ Branch 0 taken 2480 times.
✓ Branch 1 taken 5885 times.
 8365 !is_create_table_atomic) {
11022 /*
11023 CREATE ... SELECT (without TEMPORARY) for engines not supporting
11024 atomic DDL is unsafe because if binlog_format=row it will be
11025 logged as a CREATE TABLE followed by row events, re-executed
11026 non-atomically as two transactions, and then written to the
11027 slave's binary log as two separate transactions with the same
11028 GTID.
11029 */
11030
1/2
✓ Branch 0 taken 2480 times.
✗ Branch 1 not taken.
 2480 return handle_gtid_consistency_violation(
11031 this, ER_GTID_UNSAFE_CREATE_SELECT,
11032 2480 ER_RPL_GTID_UNSAFE_STMT_CREATE_SELECT);
11033 }
11034
11035
6/6
✓ Branch 0 taken 22916196 times.
✓ Branch 1 taken 9860 times.
✓ Branch 2 taken 5939 times.
✓ Branch 3 taken 22910257 times.
✓ Branch 4 taken 3818 times.
✓ Branch 5 taken 11981 times.
 22926056 if ((is_create_temporary_table || is_drop_temporary_table) &&
11036
2/2
✓ Branch 0 taken 3332 times.
✓ Branch 1 taken 486 times.
 3818 is_binlog_format_statement &&
11037
2/2
✓ Branch 0 taken 385 times.
✓ Branch 1 taken 2947 times.
 3332 (is_in_transaction || is_in_sub_statement)) {
11038 /*
11039 When @@session.binlog_format=statement,
11040 [CREATE|DROP] TEMPORARY TABLE is unsafe to execute inside a
11041 transaction or Procedure, because the [CREATE|DROP] statement on
11042 the temporary table will be executed and written into binary log
11043 with a GTID even if the transaction or Procedure is rolled back.
11044 */
11045
1/2
✓ Branch 0 taken 486 times.
✗ Branch 1 not taken.
 896 return handle_gtid_consistency_violation(
11046 this, ER_CLIENT_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRX_IN_SBR,
11047 486 ER_SERVER_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRX_IN_SBR);
11048 }
11049
11050 22925160 return true;
11051 29133852 }
11052
11053 31947024 bool THD::is_dml_gtid_compatible(bool some_transactional_table,
11054 bool some_non_transactional_table,
11055 bool non_transactional_tables_are_tmp) {
11056
1/2
✓ Branch 0 taken 31948587 times.
✗ Branch 1 not taken.
 31947024 DBUG_TRACE;
11057
11058 // If @@session.sql_log_bin has been manually turned off (only
11059 // doable by SUPER), then no problem, we can execute any statement.
11060
2/4
✓ Branch 0 taken 31948601 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 31948520 times.
 63897121 if ((variables.option_bits & OPTION_BIN_LOG) == 0 ||
11061
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 31948520 times.
 31948601 mysql_bin_log.is_open() == false)
11062 ✗ return true;
11063
11064 /*
11065 Single non-transactional updates are allowed when not mixed
11066 together with transactional statements within a transaction.
11067 Furthermore, writing to transactional and non-transactional
11068 engines in a single statement is also disallowed.
11069 Multi-statement transactions on non-transactional tables are
11070 split into single-statement transactions when
11071 GTID_NEXT = "AUTOMATIC".
11072
11073 Non-transactional updates are allowed when row binlog format is
11074 used and all non-transactional tables are temporary.
11075
11076 The debug symbol "allow_gtid_unsafe_non_transactional_updates"
11077 disables the error. This is useful because it allows us to run
11078 old tests that were not written with the restrictions of GTIDs in
11079 mind.
11080 */
11081
6/10
✓ Branch 0 taken 31948548 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31948638 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 148 times.
✓ Branch 5 taken 31948490 times.
✓ Branch 6 taken 148 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 148 times.
✗ Branch 9 not taken.
 31948520 DBUG_PRINT("info", ("some_non_transactional_table=%d "
11082 "some_transactional_table=%d "
11083 "trans_has_updated_trans_table=%d "
11084 "non_transactional_tables_are_tmp=%d "
11085 "is_current_stmt_binlog_format_row=%d",
11086 some_non_transactional_table, some_transactional_table,
11087 trans_has_updated_trans_table(this),
11088 non_transactional_tables_are_tmp,
11089 is_current_stmt_binlog_format_row()));
11090
2/2
✓ Branch 0 taken 387813 times.
✓ Branch 1 taken 2117 times.
 389930 if (some_non_transactional_table &&
11091
3/4
✓ Branch 0 taken 387877 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2177 times.
✓ Branch 3 taken 385700 times.
 387813 (some_transactional_table || trans_has_updated_trans_table(this)) &&
11092
3/4
✓ Branch 0 taken 568 times.
✓ Branch 1 taken 3726 times.
✓ Branch 2 taken 870 times.
✗ Branch 3 not taken.
 4862 !(non_transactional_tables_are_tmp &&
11093
4/4
✓ Branch 0 taken 389930 times.
✓ Branch 1 taken 31558708 times.
✓ Branch 2 taken 3977 times.
✓ Branch 3 taken 31944041 times.
 32338516 is_current_stmt_binlog_format_row()) &&
11094
2/4
✓ Branch 0 taken 3977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3977 times.
✗ Branch 3 not taken.
 4661 !DBUG_EVALUATE_IF("allow_gtid_unsafe_non_transactional_updates", 1, 0)) {
11095
1/2
✓ Branch 0 taken 3977 times.
✗ Branch 1 not taken.
 3977 return handle_gtid_consistency_violation(
11096 this, ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE,
11097 3977 ER_RPL_GTID_UNSAFE_STMT_ON_NON_TRANS_TABLE);
11098 }
11099
11100 31944041 return true;
11101 31948018 }
11102
11103 /*
11104 Implementation of interface to write rows to the binary log through the
11105 thread. The thread is responsible for writing the rows it has
11106 inserted/updated/deleted.
11107 */
11108
11109 /*
11110 Template member function for ensuring that there is an rows log
11111 event of the appropriate type before proceeding.
11112
11113 PRE CONDITION:
11114 - Events of type 'RowEventT' have the type code 'type_code'.
11115
11116 POST CONDITION:
11117 If a non-NULL pointer is returned, the pending event for thread 'thd' will
11118 be an event of type 'RowEventT' (which have the type code 'type_code')
11119 will either empty or have enough space to hold 'needed' bytes. In
11120 addition, the columns bitmap will be correct for the row, meaning that
11121 the pending event will be flushed if the columns in the event differ from
11122 the columns suppled to the function.
11123
11124 RETURNS
11125 If no error, a non-NULL pending event (either one which already existed or
11126 the newly created one).
11127 If error, NULL.
11128 */
11129
11130 template <class RowsEventT>
11131 190874398 Rows_log_event *THD::binlog_prepare_pending_rows_event(
11132 TABLE *table, uint32 serv_id, size_t needed, bool is_transactional,
11133 const unsigned char *extra_row_info, uint32 source_part_id) {
11134
1/2
✓ Branch 0 taken 95448963 times.
✗ Branch 1 not taken.
 190874398 DBUG_TRACE;
11135
11136
3/4
✓ Branch 0 taken 95440116 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 95440110 times.
 190897926 DBUG_EXECUTE_IF("simulate_null_pending_rows_event", { return nullptr; });
11137
11138 /* Fetch the type code for the RowsEventT template parameter */
11139 190880220 int const general_type_code = RowsEventT::TYPE_CODE;
11140
11141 190880220 partition_info *part_info = table->part_info;
11142
1/2
✓ Branch 0 taken 95421613 times.
✗ Branch 1 not taken.
 190880220 auto part_id = get_rpl_part_id(part_info);
11143
11144
1/2
✓ Branch 0 taken 95401010 times.
✗ Branch 1 not taken.
 190843226 Rows_log_event *pending = binlog_get_pending_rows_event(is_transactional);
11145
11146
5/8
✓ Branch 0 taken 84973969 times.
✓ Branch 1 taken 10427041 times.
✓ Branch 2 taken 84984114 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 84984114 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 95412851 times.
 190802020 if (unlikely(pending && !pending->is_valid())) return nullptr;
11147
11148 /*
11149 Check if the current event is non-NULL and a write-rows
11150 event. Also check if the table provided is mapped: if it is not,
11151 then we have switched to writing to a new table.
11152 If there is no pending event, we need to create one. If there is a pending
11153 event, but it's not about the same table id, or not of the same type
11154 (between Write, Update and Delete), or not the same affected columns, or
11155 going to be too big, flush this event to disk and create a new pending
11156 event.
11157
11158 We do not need to check that the pending event and the new event
11159 have the same setting for partial json updates, because
11160 partialness of json can only be changed outside transactions.
11161 */
11162
3/4
✓ Branch 0 taken 84986756 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84963113 times.
✓ Branch 3 taken 32596 times.
 339959226 if (!pending || pending->server_id != serv_id ||
11163 169973512 pending->get_table_id() != table->s->table_map_id ||
11164
2/4
✓ Branch 0 taken 84947638 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84960735 times.
✗ Branch 3 not taken.
 169926226 pending->get_general_type_code() != general_type_code ||
11165
3/4
✓ Branch 0 taken 84976594 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84561992 times.
✓ Branch 3 taken 414602 times.
 169921470 pending->get_data_size() + needed > binlog_row_event_max_size ||
11166
6/8
✓ Branch 0 taken 84983904 times.
✓ Branch 1 taken 10428947 times.
✓ Branch 2 taken 84552054 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 84556206 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 26053452 times.
✓ Branch 7 taken 69350625 times.
 529908250 pending->read_write_bitmaps_cmp(table) == false ||
11167
3/4
✓ Branch 0 taken 84548033 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15197372 times.
✓ Branch 3 taken 69350661 times.
 169112412 !(pending->m_extra_row_info.compare_extra_row_info(
11168 extra_row_info, part_id, source_part_id))) {
11169 /* Create a new RowsEventT... */
11170
1/2
✓ Branch 0 taken 26054021 times.
✗ Branch 1 not taken.
 52106904 Rows_log_event *const ev = new RowsEventT(
11171
1/2
✓ Branch 0 taken 26053739 times.
✗ Branch 1 not taken.
 52108042 this, table, table->s->table_map_id, is_transactional, extra_row_info);
11172
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26053779 times.
 52107478 if (unlikely(!ev)) return nullptr;
11173 52107558 ev->server_id = serv_id; // I don't like this, it's too easy to forget.
11174 /*
11175 flush the pending event and replace it with the newly created
11176 event...
11177 */
11178
2/4
✓ Branch 0 taken 26053923 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 26053901 times.
 52107558 if (unlikely(mysql_bin_log.flush_and_set_pending_rows_event(
11179 this, ev, is_transactional))) {
11180 ✗ delete ev;
11181 4 return nullptr;
11182 }
11183
11184 52107802 return ev; /* This is the new pending event */
11185 }
11186 138701250 return pending; /* This is the current pending event */
11187 190809068 }
11188
11189 /* Declare in unnamed namespace. */
11190 namespace {
11191
11192 /**
11193 Class to handle temporary allocation of memory for row data.
11194
11195 The responsibilities of the class is to provide memory for
11196 packing one or two rows of packed data (depending on what
11197 constructor is called).
11198
11199 In order to make the allocation more efficient for rows without blobs,
11200 a pointer to the allocated memory is stored in the table structure
11201 for such rows. If memory for a table containing a blob field
11202 is requested, only memory for that is allocated, and subsequently
11203 released when the object is destroyed.
11204
11205 */
11206 class Row_data_memory {
11207 public:
11208 /**
11209 Build an object to keep track of a block-local piece of memory
11210 for storing a row of data.
11211
11212 @param table
11213 Table where the pre-allocated memory is stored.
11214
11215 @param data
11216 Pointer to the table record.
11217 */
11218 92377214 Row_data_memory(TABLE *table, const uchar *data) : m_memory(nullptr) {
11219 #ifndef NDEBUG
11220 92377214 m_alloc_checked = false;
11221 #endif
11222 92377214 allocate_memory(table, max_row_length(table, data));
11223
1/2
✓ Branch 0 taken 92430388 times.
✗ Branch 1 not taken.
 92433384 m_ptr[0] = has_memory() ? m_memory : nullptr;
11224 92430388 m_ptr[1] = nullptr;
11225 92430388 }
11226
11227 3018045 Row_data_memory(TABLE *table, const uchar *data1, const uchar *data2,
11228 ulonglong value_options = 0)
11229 3018045 : m_memory(nullptr) {
11230 #ifndef NDEBUG
11231 3018045 m_alloc_checked = false;
11232 #endif
11233 3018045 size_t len1 = max_row_length(table, data1);
11234 3018045 size_t len2 = max_row_length(table, data2, value_options);
11235 3018045 allocate_memory(table, len1 + len2);
11236
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 m_ptr[0] = has_memory() ? m_memory : nullptr;
11237
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 m_ptr[1] = has_memory() ? m_memory + len1 : nullptr;
11238 3018045 }
11239
11240 95435914 ~Row_data_memory() {
11241
3/4
✓ Branch 0 taken 95439839 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3816325 times.
✓ Branch 3 taken 91623514 times.
 95435914 if (m_memory != nullptr && m_release_memory_on_destruction)
11242 3816325 my_free(m_memory);
11243 95435915 }
11244
11245 /**
11246 Is there memory allocated?
11247
11248 @retval true There is memory allocated
11249 @retval false Memory allocation failed
11250 */
11251 193864893 bool has_memory() const {
11252 #ifndef NDEBUG
11253 193864893 m_alloc_checked = true;
11254 #endif
11255 193864893 return m_memory != nullptr;
11256 }
11257
11258 98466648 uchar *slot(uint s) {
11259
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 98466648 times.
 98466648 assert(s < sizeof(m_ptr) / sizeof(*m_ptr));
11260
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 98466648 times.
 98466648 assert(m_ptr[s] != nullptr);
11261
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 98466648 times.
 98466648 assert(m_alloc_checked == true);
11262 98466648 return m_ptr[s];
11263 }
11264
11265 private:
11266 /**
11267 Compute an upper bound on the amount of memory needed.
11268
11269 This may return an over-approximation.
11270
11271 @param table The table
11272 @param data The server's row record.
11273 @param value_options The value of @@global.binlog_row_value_options
11274 */
11275 98402942 size_t max_row_length(TABLE *table, const uchar *data,
11276 ulonglong value_options = 0) {
11277 98402942 TABLE_SHARE *table_s = table->s;
11278
1/2
✓ Branch 0 taken 98472910 times.
✗ Branch 1 not taken.
 98402942 Replicated_columns_view fields{table, Replicated_columns_view::OUTBOUND};
11279 /*
11280 The server stores rows using "records". A record is a sequence of bytes
11281 which contains values or pointers to values for all fields (columns). The
11282 server uses table_s->reclength bytes for a row record.
11283
11284 The layout of a record is roughly:
11285
11286 - N+1+B bits, packed into CEIL((N+1+B)/8) bytes, where N is the number of
11287 nullable columns in the table, and B is the sum of the number of bits of
11288 all BIT columns.
11289
11290 - A sequence of serialized fields, each corresponding to a non-BIT,
11291 non-NULL column in the table.
11292
11293 For variable-length columns, the first component of the serialized field
11294 is a length, stored using 1, 2, 3, or 4 bytes depending on the maximum
11295 length for the data type.
11296
11297 For most data types, the next component of the serialized field is the
11298 actual data. But for for VARCHAR, VARBINARY, TEXT, BLOB, and JSON, the
11299 next component of the serialized field is a serialized pointer,
11300 i.e. sizeof(pointer) bytes, which point to another memory area where the
11301 actual data is stored.
11302
11303 The layout of a row image in the binary log is roughly:
11304
11305 - If this is an after-image and partial JSON is enabled, 1 byte containing
11306 value_options. If the PARTIAL_JSON bit of value_options is set, this is
11307 followed by P bits (the "partial_bits"), packed into CEIL(P) bytes,
11308 where P is the number of JSON columns in the table.
11309
11310 - M bits (the "null_bits"), packed into CEIL(M) bytes, where M is the
11311 number of columns in the image.
11312
11313 - A sequence of serialized fields, each corresponding to a non-NULL column
11314 in the row image.
11315
11316 For variable-length columns, the first component of the serialized field
11317 is a length, stored using 1, 2, 3, or 4 bytes depending on the maximum
11318 length for the data type.
11319
11320 For most data types, the next component of the serialized field is the
11321 actual field data. But for JSON fields where the corresponding bit of
11322 the partial_bits is 1, this is a sequence of diffs instead.
11323
11324 Now we try to use table_s->reclength to estimate how much memory to
11325 allocate for a row image in the binlog. Due to the differences this will
11326 only be an upper bound. Notice the differences:
11327
11328 - The binlog may only include a subset of the fields (the row image),
11329 whereas reclength contains space for all fields.
11330
11331 - BIT columns are not packed together with NULL bits in the binlog, so up
11332 to 1 more byte per BIT column may be needed.
11333
11334 - The binlog has a null bit even for non-nullable fields, whereas the
11335 reclength only contains space nullable fields, so the binlog may need up
11336 to CEIL(table_s->fields/8) more bytes.
11337
11338 - The binlog only has a null bit for fields in the image, whereas the
11339 reclength contains space for all fields.
11340
11341 - The binlog contains the full blob whereas the record only contains
11342 sizeof(pointer) bytes.
11343
11344 - The binlog contains value_options and partial_bits. So this may use up
11345 to 1+CEIL(table_s->fields/8) more bytes.
11346
11347 - The binlog may contain partial JSON. This is guaranteed to be smaller
11348 than the size of the full value.
11349
11350 - There may exist columns that, due to their nature, are not replicated,
11351 for instance, hidden generated columns used for functional indexes.
11352
11353 For those data types that are not stored using a pointer, the size of the
11354 field in the binary log is at most 2 bytes more than what the field
11355 contributes to in table_s->reclength, because those data types use at most
11356 1 byte for the length and waste less than a byte on extra padding and
11357 extra bits in null_bits or BIT columns.
11358
11359 For those data types that are stored using a pointer, the size of the
11360 field in the binary log is at most 2 bytes more than what the field
11361 contributes to in table_s->reclength, plus the size of the data. The size
11362 of the pointer is at least 4 on all supported platforms, so it is bigger
11363 than what is used by partial_bits, value_format, or any waste due to extra
11364 padding and extra bits in null_bits.
11365 */
11366 98472910 size_t length = table_s->reclength + 2 * (fields.filtered_size());
11367
11368
2/2
✓ Branch 0 taken 7121237 times.
✓ Branch 1 taken 98386799 times.
 105508036 for (uint i = 0; i < table_s->blob_fields; i++) {
11369
2/2
✓ Branch 0 taken 1259 times.
✓ Branch 1 taken 7120038 times.
 7121237 if (fields.is_excluded(table_s->blob_field[i])) continue;
11370
11371 7120038 Field *field = table->field[table_s->blob_field[i]];
11372 7120038 Field_blob *field_blob = down_cast<Field_blob *>(field);
11373
11374
5/6
✓ Branch 0 taken 7120037 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 322505 times.
✓ Branch 3 taken 6797532 times.
✓ Branch 4 taken 6738 times.
✓ Branch 5 taken 7113299 times.
 7442539 if (field_blob->type() == MYSQL_TYPE_JSON &&
11375
2/2
✓ Branch 0 taken 6738 times.
✓ Branch 1 taken 315767 times.
 322505 (value_options & PARTIAL_JSON_UPDATES) != 0) {
11376 6738 Field_json *field_json = down_cast<Field_json *>(field_blob);
11377
1/2
✓ Branch 0 taken 6738 times.
✗ Branch 1 not taken.
 6738 length += field_json->get_diff_vector_and_length(value_options);
11378 } else
11379 7113298 length +=
11380
1/2
✓ Branch 0 taken 7113298 times.
✗ Branch 1 not taken.
 7113299 field_blob->get_length(data + field_blob->offset(table->record[0]));
11381 }
11382 98469071 return length;
11383 98386799 }
11384
11385 95444125 void allocate_memory(TABLE *const table, const size_t total_length) {
11386
2/2
✓ Branch 0 taken 91633275 times.
✓ Branch 1 taken 3810850 times.
 95444125 if (table->s->blob_fields == 0) {
11387 /*
11388 The maximum length of a packed record is less than this
11389 length. We use this value instead of the supplied length
11390 when allocating memory for records, since we don't know how
11391 the memory will be used in future allocations.
11392
11393 Since table->s->reclength is for unpacked records, we have
11394 to add two bytes for each field, which can potentially be
11395 added to hold the length of a packed field.
11396 */
11397 91633275 size_t const maxlen = table->s->reclength + 2 * table->s->fields;
11398
11399 /*
11400 Allocate memory for two records if memory hasn't been
11401 allocated. We allocate memory for two records so that it can
11402 be used when processing update rows as well.
11403 */
11404
2/2
✓ Branch 0 taken 84892 times.
✓ Branch 1 taken 91548383 times.
 91633275 if (table->write_row_record == nullptr)
11405 84892 table->write_row_record = (uchar *)table->mem_root.Alloc(2 * maxlen);
11406 91633275 m_memory = table->write_row_record;
11407 91633275 m_release_memory_on_destruction = false;
11408 } else {
11409 3810850 m_memory = (uchar *)my_malloc(key_memory_Row_data_memory_memory,
11410 total_length, MYF(MY_WME));
11411 3816326 m_release_memory_on_destruction = true;
11412 }
11413 95449601 }
11414
11415 #ifndef NDEBUG
11416 mutable bool m_alloc_checked;
11417 #endif
11418 bool m_release_memory_on_destruction;
11419 uchar *m_memory;
11420 uchar *m_ptr[2];
11421 };
11422
11423 } // namespace
11424
11425 90373260 int THD::binlog_write_row(TABLE *table, bool is_trans, uchar const *record,
11426 const unsigned char *extra_row_info) {
11427
3/4
✓ Branch 0 taken 90415057 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 90415966 times.
✓ Branch 3 taken 4162 times.
 90373260 assert(is_current_stmt_binlog_format_row() && mysql_bin_log.is_open());
11428
11429 /*
11430 Pack records into format for transfer. We are allocating more
11431 memory than needed, but that doesn't matter.
11432 */
11433
1/2
✓ Branch 0 taken 90446200 times.
✗ Branch 1 not taken.
 90415966 Row_data_memory memory(table, record);
11434
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 90444310 times.
 90446200 if (!memory.has_memory()) return HA_ERR_OUT_OF_MEM;
11435
11436 90444310 uchar *row_data = memory.slot(0);
11437
11438
1/2
✓ Branch 0 taken 90450147 times.
✗ Branch 1 not taken.
 90447631 size_t const len = pack_row(table, table->write_set, row_data, record,
11439 enum_row_image_type::WRITE_AI);
11440
11441 Rows_log_event *const ev =
11442
1/2
✓ Branch 0 taken 90443893 times.
✗ Branch 1 not taken.
 90450147 binlog_prepare_pending_rows_event<Write_rows_log_event>(
11443 table, server_id, len, is_trans, extra_row_info);
11444
11445
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 90444189 times.
 90443893 if (unlikely(ev == nullptr)) return HA_ERR_OUT_OF_MEM;
11446
11447
1/2
✓ Branch 0 taken 90438129 times.
✗ Branch 1 not taken.
 90444189 return ev->add_row_data(row_data, len);
11448 90438133 }
11449
11450 3018045 int THD::binlog_update_row(TABLE *table, bool is_trans,
11451 const uchar *before_record,
11452 const uchar *after_record,
11453 const unsigned char *extra_row_info) {
11454
2/4
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3018045 times.
✗ Branch 3 not taken.
 3018045 assert(is_current_stmt_binlog_format_row() && mysql_bin_log.is_open());
11455 3018045 int error = 0;
11456
11457 /**
11458 Save a reference to the original read and write set bitmaps.
11459 We will need this to restore the bitmaps at the end.
11460 */
11461 3018045 MY_BITMAP *old_read_set = table->read_set;
11462 3018045 MY_BITMAP *old_write_set = table->write_set;
11463
11464 /**
11465 This will remove spurious fields required during execution but
11466 not needed for binlogging. This is done according to the:
11467 binlog-row-image option.
11468 */
11469
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 binlog_prepare_row_images(this, table);
11470
11471 Row_data_memory row_data(table, before_record, after_record,
11472
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 variables.binlog_row_value_options);
11473
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3018045 times.
 3018045 if (!row_data.has_memory()) return HA_ERR_OUT_OF_MEM;
11474
11475 3018045 uchar *before_row = row_data.slot(0);
11476 3018045 uchar *after_row = row_data.slot(1);
11477
11478 size_t const before_size =
11479
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 pack_row(table, table->read_set, before_row, before_record,
11480 enum_row_image_type::UPDATE_BI);
11481 6036090 size_t const after_size = pack_row(
11482
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 table, table->write_set, after_row, after_record,
11483 enum_row_image_type::UPDATE_AI, variables.binlog_row_value_options);
11484
11485
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 DBUG_DUMP("before_record", before_record, table->s->reclength);
11486
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 DBUG_DUMP("after_record", after_record, table->s->reclength);
11487
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 DBUG_DUMP("before_row", before_row, before_size);
11488
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 DBUG_DUMP("after_row", after_row, after_size);
11489
11490 3018045 partition_info *part_info = table->part_info;
11491 3018045 uint32 source_part_id = binary_log::Rows_event::Extra_row_info::UNDEFINED;
11492
2/2
✓ Branch 0 taken 55279 times.
✓ Branch 1 taken 2962766 times.
 3018045 if (part_info) {
11493 55279 uint32 new_part_id = binary_log::Rows_event::Extra_row_info::UNDEFINED;
11494 55279 longlong func_value = 0;
11495
1/2
✓ Branch 0 taken 55279 times.
✗ Branch 1 not taken.
 55279 get_parts_for_update(before_record, after_record, table->record[0],
11496 part_info, &source_part_id, &new_part_id, &func_value);
11497 }
11498
11499 Rows_log_event *const ev =
11500
1/2
✓ Branch 0 taken 3018045 times.
✗ Branch 1 not taken.
 3018045 binlog_prepare_pending_rows_event<Update_rows_log_event>(
11501 table, server_id, before_size + after_size, is_trans, extra_row_info,
11502 source_part_id);
11503
11504
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3018043 times.
 3018045 if (unlikely(ev == nullptr)) return HA_ERR_OUT_OF_MEM;
11505
11506
2/2
✓ Branch 0 taken 55278 times.
✓ Branch 1 taken 2962765 times.
 3018043 if (part_info) {
11507 55278 ev->m_extra_row_info.set_source_partition_id(source_part_id);
11508 }
11509
11510
2/4
✓ Branch 0 taken 3018042 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3018042 times.
✗ Branch 3 not taken.
 6036086 error = ev->add_row_data(before_row, before_size) ||
11511
2/4
✓ Branch 0 taken 3018043 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3018043 times.
 3018042 ev->add_row_data(after_row, after_size);
11512
11513 /* restore read/write set for the rest of execution */
11514 3018043 table->column_bitmaps_set_no_signal(old_read_set, old_write_set);
11515
11516 3018042 bitmap_clear_all(&table->tmp_set);
11517
11518 3018042 return error;
11519 3018044 }
11520
11521 1984449 int THD::binlog_delete_row(TABLE *table, bool is_trans, uchar const *record,
11522 const unsigned char *extra_row_info) {
11523
2/4
✓ Branch 0 taken 1984449 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1984449 times.
✗ Branch 3 not taken.
 1984449 assert(is_current_stmt_binlog_format_row() && mysql_bin_log.is_open());
11524 1984449 int error = 0;
11525
11526 /**
11527 Save a reference to the original read and write set bitmaps.
11528 We will need this to restore the bitmaps at the end.
11529 */
11530 1984449 MY_BITMAP *old_read_set = table->read_set;
11531 1984449 MY_BITMAP *old_write_set = table->write_set;
11532
11533 /**
11534 This will remove spurious fields required during execution but
11535 not needed for binlogging. This is done according to the:
11536 binlog-row-image option.
11537 */
11538
1/2
✓ Branch 0 taken 1984449 times.
✗ Branch 1 not taken.
 1984449 binlog_prepare_row_images(this, table);
11539
11540 /*
11541 Pack records into format for transfer. We are allocating more
11542 memory than needed, but that doesn't matter.
11543 */
11544
1/2
✓ Branch 0 taken 1984449 times.
✗ Branch 1 not taken.
 1984449 Row_data_memory memory(table, record);
11545
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1984449 times.
 1984449 if (unlikely(!memory.has_memory())) return HA_ERR_OUT_OF_MEM;
11546
11547 1984449 uchar *row_data = memory.slot(0);
11548
11549
1/2
✓ Branch 0 taken 1984449 times.
✗ Branch 1 not taken.
 1984449 DBUG_DUMP("table->read_set", (uchar *)table->read_set->bitmap,
11550 (table->s->fields + 7) / 8);
11551
1/2
✓ Branch 0 taken 1984449 times.
✗ Branch 1 not taken.
 1984449 size_t const len = pack_row(table, table->read_set, row_data, record,
11552 enum_row_image_type::DELETE_BI);
11553
11554 Rows_log_event *const ev =
11555
1/2
✓ Branch 0 taken 1984449 times.
✗ Branch 1 not taken.
 1984449 binlog_prepare_pending_rows_event<Delete_rows_log_event>(
11556 table, server_id, len, is_trans, extra_row_info);
11557
11558
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1984447 times.
 1984449 if (unlikely(ev == nullptr)) return HA_ERR_OUT_OF_MEM;
11559
11560
1/2
✓ Branch 0 taken 1984447 times.
✗ Branch 1 not taken.
 1984447 error = ev->add_row_data(row_data, len);
11561
11562 /* restore read/write set for the rest of execution */
11563 1984447 table->column_bitmaps_set_no_signal(old_read_set, old_write_set);
11564
11565 1984447 bitmap_clear_all(&table->tmp_set);
11566 1984447 return error;
11567 1984449 }
11568
11569 5002494 void binlog_prepare_row_images(const THD *thd, TABLE *table) {
11570
1/2
✓ Branch 0 taken 5002494 times.
✗ Branch 1 not taken.
 5002494 DBUG_TRACE;
11571 /**
11572 Remove from read_set spurious columns. The write_set has been
11573 handled before in table->mark_columns_needed_for_update.
11574 */
11575
11576
9/12
✓ Branch 0 taken 21139941 times.
✓ Branch 1 taken 17292 times.
✓ Branch 2 taken 21157233 times.
✓ Branch 3 taken 5002494 times.
✓ Branch 4 taken 5002494 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5002494 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✓ Branch 9 taken 5002490 times.
✓ Branch 10 taken 4 times.
✗ Branch 11 not taken.
 26159727 DBUG_PRINT_BITSET("debug", "table->read_set (before preparing): %s",
11577 table->read_set);
11578
11579 /**
11580 if there is a primary key in the table (ie, user declared PK or a
11581 non-null unique index) and we dont want to ship the entire image,
11582 and the handler involved supports this.
11583 */
11584 13757704 if (table->s->primary_key < MAX_KEY &&
11585
6/6
✓ Branch 0 taken 3752716 times.
✓ Branch 1 taken 1249778 times.
✓ Branch 2 taken 17094 times.
✓ Branch 3 taken 3735622 times.
✓ Branch 4 taken 17094 times.
✓ Branch 5 taken 4985400 times.
 5019588 (thd->variables.binlog_row_image < BINLOG_ROW_IMAGE_FULL) &&
11586
2/4
✓ Branch 0 taken 17094 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17094 times.
✗ Branch 3 not taken.
 17094 !ha_check_storage_engine_flag(table->s->db_type(),
11587 HTON_NO_BINLOG_ROW_OPT)) {
11588 /**
11589 Just to be sure that tmp_set is currently not in use as
11590 the read_set already.
11591 */
11592
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17094 times.
 17094 assert(table->read_set != &table->tmp_set);
11593 // Verify it's not used
11594
2/4
✓ Branch 0 taken 17094 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 17094 times.
 17094 assert(bitmap_is_clear_all(&table->tmp_set));
11595
11596
2/3
✓ Branch 0 taken 9332 times.
✓ Branch 1 taken 7762 times.
✗ Branch 2 not taken.
 17094 switch (thd->variables.binlog_row_image) {
11597 9332 case BINLOG_ROW_IMAGE_MINIMAL:
11598 /* MINIMAL: Mark only PK */
11599
1/2
✓ Branch 0 taken 9332 times.
✗ Branch 1 not taken.
 9332 table->mark_columns_used_by_index_no_reset(table->s->primary_key,
11600 &table->tmp_set);
11601 9332 break;
11602 7762 case BINLOG_ROW_IMAGE_NOBLOB:
11603 /**
11604 NOBLOB: Remove unnecessary BLOB fields from read_set
11605 (the ones that are not part of PK).
11606 */
11607
1/2
✓ Branch 0 taken 7762 times.
✗ Branch 1 not taken.
 7762 bitmap_union(&table->tmp_set, table->read_set);
11608
2/2
✓ Branch 0 taken 25217 times.
✓ Branch 1 taken 7762 times.
 32979 for (Field **ptr = table->field; *ptr; ptr++) {
11609 25217 Field *field = (*ptr);
11610
5/6
✓ Branch 0 taken 25217 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5851 times.
✓ Branch 3 taken 19366 times.
✓ Branch 4 taken 4277 times.
✓ Branch 5 taken 20940 times.
 31068 if ((field->type() == MYSQL_TYPE_BLOB) &&
11611
2/2
✓ Branch 0 taken 4277 times.
✓ Branch 1 taken 1574 times.
 5851 !field->is_flag_set(PRI_KEY_FLAG))
11612 4277 bitmap_clear_bit(&table->tmp_set, field->field_index());
11613 }
11614 7762 break;
11615 ✗ default:
11616 ✗ assert(0); // impossible.
11617 }
11618
11619 /* set the temporary read_set */
11620 17094 table->column_bitmaps_set_no_signal(&table->tmp_set, table->write_set);
11621 }
11622
11623
9/12
✓ Branch 0 taken 21131319 times.
✓ Branch 1 taken 25914 times.
✓ Branch 2 taken 21157233 times.
✓ Branch 3 taken 5002494 times.
✓ Branch 4 taken 5002494 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5002494 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✓ Branch 9 taken 5002490 times.
✓ Branch 10 taken 4 times.
✗ Branch 11 not taken.
 26159727 DBUG_PRINT_BITSET("debug", "table->read_set (after preparing): %s",
11624 table->read_set);
11625 5002494 }
11626
11627 94351607 int THD::binlog_flush_pending_rows_event(bool stmt_end, bool is_transactional) {
11628
1/2
✓ Branch 0 taken 94353646 times.
✗ Branch 1 not taken.
 94351607 DBUG_TRACE;
11629 /*
11630 We shall flush the pending event even if we are not in row-based
11631 mode: it might be the case that we left row-based mode before
11632 flushing anything (e.g., if we have explicitly locked tables).
11633 */
11634
2/2
✓ Branch 0 taken 35378847 times.
✓ Branch 1 taken 58974639 times.
 94353646 if (!mysql_bin_log.is_open()) return 0;
11635
11636 /*
11637 Mark the event as the last event of a statement if the stmt_end
11638 flag is set.
11639 */
11640 58974639 int error = 0;
11641 58974758 if (Rows_log_event *pending =
11642
3/4
✓ Branch 0 taken 58974758 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10413940 times.
✓ Branch 3 taken 48560818 times.
 58974639 binlog_get_pending_rows_event(is_transactional)) {
11643
1/2
✓ Branch 0 taken 10413987 times.
✗ Branch 1 not taken.
 10413940 if (stmt_end) {
11644 10413987 pending->set_flags(Rows_log_event::STMT_END_F);
11645 10413868 binlog_table_maps = 0;
11646 }
11647
11648
1/2
✓ Branch 0 taken 10414029 times.
✗ Branch 1 not taken.
 10413821 error = mysql_bin_log.flush_and_set_pending_rows_event(this, nullptr,
11649 is_transactional);
11650 }
11651
11652 58974847 return error;
11653 94353694 }
11654
11655 #if !defined(NDEBUG)
11656 106 static const char *show_query_type(THD::enum_binlog_query_type qtype) {
11657
2/3
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 86 times.
✗ Branch 2 not taken.
 106 switch (qtype) {
11658 20 case THD::ROW_QUERY_TYPE:
11659 20 return "ROW";
11660 86 case THD::STMT_QUERY_TYPE:
11661 86 return "STMT";
11662 ✗ case THD::QUERY_TYPE_COUNT:
11663 default:
11664 ✗ assert(0 <= qtype && qtype < THD::QUERY_TYPE_COUNT);
11665 }
11666 static char buf[64];
11667 ✗ sprintf(buf, "UNKNOWN#%d", qtype);
11668 ✗ return buf;
11669 }
11670 #endif
11671
11672 /**
11673 Auxiliary function to reset the limit unsafety warning suppression.
11674 */
11675 ✗ static void reset_binlog_unsafe_suppression() {
11676 ✗ DBUG_TRACE;
11677 ✗ unsafe_warning_suppression_is_activated = false;
11678 ✗ limit_unsafe_warning_count = 0;
11679 ✗ limit_unsafe_suppression_start_time = my_getsystime() / 10000000;
11680 }
11681
11682 /**
11683 Auxiliary function to print warning in the error log.
11684 */
11685 2492 static void print_unsafe_warning_to_log(int unsafe_type, char *buf,
11686 const char *query) {
11687
1/2
✓ Branch 0 taken 2492 times.
✗ Branch 1 not taken.
 2492 DBUG_TRACE;
11688
1/2
✓ Branch 0 taken 2492 times.
✗ Branch 1 not taken.
 2492 sprintf(buf, ER_DEFAULT(ER_BINLOG_UNSAFE_STATEMENT),
11689
1/2
✓ Branch 0 taken 2492 times.
✗ Branch 1 not taken.
 2492 ER_DEFAULT_NONCONST(LEX::binlog_stmt_unsafe_errcode[unsafe_type]));
11690
8/16
✓ Branch 0 taken 2492 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2492 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2492 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2492 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2492 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2492 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 2492 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 2492 times.
✗ Branch 15 not taken.
 2492 LogErr(WARNING_LEVEL, ER_BINLOG_UNSAFE_MESSAGE_AND_STATEMENT, buf, query);
11691 2492 }
11692
11693 /**
11694 Auxiliary function to check if the warning for limit unsafety should be
11695 thrown or suppressed. Details of the implementation can be found in the
11696 comments inline.
11697
11698 @param buf Buffer to hold the warning message text
11699 @param unsafe_type The type of unsafety.
11700 @param query The actual query statement.
11701
11702 TODO: Remove this function and implement a general service for all warnings
11703 that would prevent flooding the error log. => switch to log_throttle class?
11704 */
11705 282 static void do_unsafe_limit_checkout(char *buf, int unsafe_type,
11706 const char *query) {
11707 ulonglong now;
11708
1/2
✓ Branch 0 taken 282 times.
✗ Branch 1 not taken.
 282 DBUG_TRACE;
11709
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 282 times.
 282 assert(unsafe_type == LEX::BINLOG_STMT_UNSAFE_LIMIT);
11710 282 limit_unsafe_warning_count++;
11711 /*
11712 INITIALIZING:
11713 If this is the first time this function is called with log warning
11714 enabled, the monitoring the unsafe warnings should start.
11715 */
11716
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 273 times.
 282 if (limit_unsafe_suppression_start_time == 0) {
11717 9 limit_unsafe_suppression_start_time = my_getsystime() / 10000000;
11718
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 print_unsafe_warning_to_log(unsafe_type, buf, query);
11719 } else {
11720
1/2
✓ Branch 0 taken 273 times.
✗ Branch 1 not taken.
 273 if (!unsafe_warning_suppression_is_activated)
11721
1/2
✓ Branch 0 taken 273 times.
✗ Branch 1 not taken.
 273 print_unsafe_warning_to_log(unsafe_type, buf, query);
11722
11723
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 269 times.
 273 if (limit_unsafe_warning_count >=
11724 LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT) {
11725 4 now = my_getsystime() / 10000000;
11726
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 if (!unsafe_warning_suppression_is_activated) {
11727 /*
11728 ACTIVATION:
11729 We got LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT warnings in
11730 less than LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT we activate the
11731 suppression.
11732 */
11733
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if ((now - limit_unsafe_suppression_start_time) <=
11734 LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT) {
11735 ✗ unsafe_warning_suppression_is_activated = true;
11736 ✗ DBUG_PRINT("info", ("A warning flood has been detected and the "
11737 "limit unsafety warning suppression has been "
11738 "activated."));
11739 } else {
11740 /*
11741 there is no flooding till now, therefore we restart the monitoring
11742 */
11743 4 limit_unsafe_suppression_start_time = my_getsystime() / 10000000;
11744 4 limit_unsafe_warning_count = 0;
11745 }
11746 } else {
11747 /*
11748 Print the suppression note and the unsafe warning.
11749 */
11750 ✗ LogErr(INFORMATION_LEVEL, ER_BINLOG_WARNING_SUPPRESSED,
11751 limit_unsafe_warning_count,
11752 (int)(now - limit_unsafe_suppression_start_time));
11753 ✗ print_unsafe_warning_to_log(unsafe_type, buf, query);
11754 /*
11755 DEACTIVATION: We got LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT
11756 warnings in more than LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT, the
11757 suppression should be deactivated.
11758 */
11759 ✗ if ((now - limit_unsafe_suppression_start_time) >
11760 LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT) {
11761 ✗ reset_binlog_unsafe_suppression();
11762 ✗ DBUG_PRINT("info", ("The limit unsafety warning supression has "
11763 "been deactivated"));
11764 }
11765 }
11766 4 limit_unsafe_warning_count = 0;
11767 }
11768 }
11769 282 }
11770
11771 /**
11772 Auxiliary method used by @c binlog_query() to raise warnings.
11773
11774 The type of warning and the type of unsafeness is stored in
11775 THD::binlog_unsafe_warning_flags.
11776 */
11777 5653614 void THD::issue_unsafe_warnings() {
11778 char buf[MYSQL_ERRMSG_SIZE * 2];
11779
1/2
✓ Branch 0 taken 5653636 times.
✗ Branch 1 not taken.
 5653614 DBUG_TRACE;
11780 /*
11781 Ensure that binlog_unsafe_warning_flags is big enough to hold all
11782 bits. This is actually a constant expression.
11783 */
11784 assert(LEX::BINLOG_STMT_UNSAFE_COUNT <=
11785 sizeof(binlog_unsafe_warning_flags) * CHAR_BIT);
11786
11787 5653636 uint32 unsafe_type_flags = binlog_unsafe_warning_flags;
11788
11789
2/2
✓ Branch 0 taken 577 times.
✓ Branch 1 taken 5653059 times.
 5653636 if ((unsafe_type_flags & (1U << LEX::BINLOG_STMT_UNSAFE_LIMIT)) != 0) {
11790
2/2
✓ Branch 0 taken 502 times.
✓ Branch 1 taken 75 times.
 577 if ((lex->sql_command == SQLCOM_DELETE ||
11791
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 439 times.
 502 lex->sql_command == SQLCOM_UPDATE) &&
11792
1/2
✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
 138 lex->query_block->select_limit) {
11793 276 ORDER *order = (ORDER *)((lex->query_block->order_list.elements)
11794
2/2
✓ Branch 0 taken 103 times.
✓ Branch 1 taken 35 times.
 138 ? lex->query_block->order_list.first
11795 : nullptr);
11796 414 if ((lex->query_block->select_limit &&
11797
1/2
✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
 138 lex->query_block->select_limit->fixed &&
11798
5/8
✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 138 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 138 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 83 times.
✓ Branch 7 taken 55 times.
 414 lex->query_block->select_limit->val_int() == 0) ||
11799
3/4
✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 83 times.
✓ Branch 3 taken 55 times.
 138 is_order_deterministic(lex->query_tables,
11800 138 lex->query_block->where_cond(), order)) {
11801 83 unsafe_type_flags &= ~(1U << LEX::BINLOG_STMT_UNSAFE_LIMIT);
11802 }
11803 }
11804
2/2
✓ Branch 0 taken 230 times.
✓ Branch 1 taken 347 times.
 577 if ((lex->sql_command == SQLCOM_INSERT_SELECT ||
11805
2/2
✓ Branch 0 taken 61 times.
✓ Branch 1 taken 169 times.
 230 lex->sql_command == SQLCOM_REPLACE_SELECT) &&
11806
2/2
✓ Branch 0 taken 211 times.
✓ Branch 1 taken 197 times.
 408 order_deterministic) {
11807 211 unsafe_type_flags &= ~(1U << LEX::BINLOG_STMT_UNSAFE_LIMIT);
11808 }
11809 }
11810
11811 /*
11812 For each unsafe_type, check if the statement is unsafe in this way
11813 and issue a warning.
11814 */
11815
2/2
✓ Branch 0 taken 146983813 times.
✓ Branch 1 taken 5655607 times.
 152639420 for (int unsafe_type = 0; unsafe_type < LEX::BINLOG_STMT_UNSAFE_COUNT;
11816 unsafe_type++) {
11817
2/2
✓ Branch 0 taken 13092 times.
✓ Branch 1 taken 146970721 times.
 146983813 if ((unsafe_type_flags & (1 << unsafe_type)) != 0) {
11818
2/4
✓ Branch 0 taken 13092 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13092 times.
✗ Branch 3 not taken.
 13092 push_warning_printf(
11819 this, Sql_condition::SL_NOTE, ER_BINLOG_UNSAFE_STATEMENT,
11820 ER_THD(this, ER_BINLOG_UNSAFE_STATEMENT),
11821
1/2
✓ Branch 0 taken 13092 times.
✗ Branch 1 not taken.
 13092 ER_THD_NONCONST(this, LEX::binlog_stmt_unsafe_errcode[unsafe_type]));
11822
4/4
✓ Branch 0 taken 2493 times.
✓ Branch 1 taken 10599 times.
✓ Branch 2 taken 2492 times.
✓ Branch 3 taken 1 times.
 13092 if (log_error_verbosity > 1 && opt_log_unsafe_statements) {
11823
2/2
✓ Branch 0 taken 282 times.
✓ Branch 1 taken 2210 times.
 2492 if (unsafe_type == LEX::BINLOG_STMT_UNSAFE_LIMIT)
11824
2/4
✓ Branch 0 taken 282 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 282 times.
✗ Branch 3 not taken.
 282 do_unsafe_limit_checkout(buf, unsafe_type, query().str);
11825 else // cases other than LIMIT unsafety
11826
2/4
✓ Branch 0 taken 2210 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4181 times.
✗ Branch 3 not taken.
 2210 print_unsafe_warning_to_log(unsafe_type, buf, query().str);
11827 }
11828 }
11829 }
11830 5655607 }
11831
11832 /**
11833 Log the current query.
11834
11835 The query will be logged in either row format or statement format
11836 depending on the value of @c current_stmt_binlog_format_row field and
11837 the value of the @c qtype parameter.
11838
11839 This function must be called:
11840
11841 - After the all calls to ha_*_row() functions have been issued.
11842
11843 - After any writes to system tables. Rationale: if system tables
11844 were written after a call to this function, and the master crashes
11845 after the call to this function and before writing the system
11846 tables, then the master and slave get out of sync.
11847
11848 - Before tables are unlocked and closed.
11849
11850 @see decide_logging_format
11851
11852 @retval 0 Success
11853
11854 @retval nonzero If there is a failure when writing the query (e.g.,
11855 write failure), then the error code is returned.
11856 */
11857 11140186 int THD::binlog_query(THD::enum_binlog_query_type qtype, const char *query_arg,
11858 size_t query_len, bool is_trans, bool direct,
11859 bool suppress_use, int errcode) {
11860
1/2
✓ Branch 0 taken 11140812 times.
✗ Branch 1 not taken.
 11140186 DBUG_TRACE;
11861
5/8
✓ Branch 0 taken 11140593 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11140739 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 106 times.
✓ Branch 5 taken 11140633 times.
✓ Branch 6 taken 153 times.
✗ Branch 7 not taken.
 11140812 DBUG_PRINT("enter",
11862 ("qtype: %s query: '%s'", show_query_type(qtype), query_arg));
11863
2/4
✓ Branch 0 taken 11140786 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11140741 times.
✗ Branch 3 not taken.
 11140786 assert(query_arg && mysql_bin_log.is_open());
11864
11865
2/2
✓ Branch 0 taken 7841 times.
✓ Branch 1 taken 11132815 times.
 11140741 if (get_binlog_local_stmt_filter() == BINLOG_FILTER_SET) {
11866 /*
11867 The current statement is to be ignored, and not written to
11868 the binlog. Do not call issue_unsafe_warnings().
11869 */
11870 7841 return 0;
11871 }
11872
11873 /*
11874 If we are not in prelocked mode, mysql_unlock_tables() will be
11875 called after this binlog_query(), so we have to flush the pending
11876 rows event with the STMT_END_F set to unlock all tables at the
11877 slave side as well.
11878
11879 If we are in prelocked mode, the flushing will be done inside the
11880 top-most close_thread_tables().
11881 */
11882
2/2
✓ Branch 0 taken 11051185 times.
✓ Branch 1 taken 81630 times.
 11132815 if (this->locked_tables_mode <= LTM_LOCK_TABLES)
11883
3/4
✓ Branch 0 taken 11051294 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 11051288 times.
 11051185 if (int error = binlog_flush_pending_rows_event(true, is_trans))
11884 6 return error;
11885
11886 /*
11887 Warnings for unsafe statements logged in statement format are
11888 printed in three places instead of in decide_logging_format().
11889 This is because the warnings should be printed only if the statement
11890 is actually logged. When executing decide_logging_format(), we cannot
11891 know for sure if the statement will be logged:
11892
11893 1 - sp_head::execute_procedure which prints out warnings for calls to
11894 stored procedures.
11895
11896 2 - sp_head::execute_function which prints out warnings for calls
11897 involving functions.
11898
11899 3 - THD::binlog_query (here) which prints warning for top level
11900 statements not covered by the two cases above: i.e., if not inside a
11901 procedure and a function.
11902
11903 Besides, we should not try to print these warnings if it is not
11904 possible to write statements to the binary log as it happens when
11905 the execution is inside a function, or generally speaking, when
11906 the variables.option_bits & OPTION_BIN_LOG is false.
11907 */
11908
4/4
✓ Branch 0 taken 10933423 times.
✓ Branch 1 taken 199495 times.
✓ Branch 2 taken 5644447 times.
✓ Branch 3 taken 5288976 times.
 11132918 if ((variables.option_bits & OPTION_BIN_LOG) && sp_runtime_ctx == nullptr &&
11909
1/2
✓ Branch 0 taken 5644539 times.
✗ Branch 1 not taken.
 5644447 !binlog_evt_union.do_union) {
11910
1/2
✓ Branch 0 taken 5644529 times.
✗ Branch 1 not taken.
 5644539 issue_unsafe_warnings();
11911 5644529 order_deterministic = true;
11912 }
11913
11914
2/3
✓ Branch 0 taken 10704655 times.
✓ Branch 1 taken 428253 times.
✗ Branch 2 not taken.
 11132908 switch (qtype) {
11915 /*
11916 ROW_QUERY_TYPE means that the statement may be logged either in
11917 row format or in statement format. If
11918 current_stmt_binlog_format is row, it means that the
11919 statement has already been logged in row format and hence shall
11920 not be logged again.
11921 */
11922 10704655 case THD::ROW_QUERY_TYPE:
11923
5/8
✓ Branch 0 taken 10704588 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10704639 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 20 times.
✓ Branch 5 taken 10704619 times.
✓ Branch 6 taken 20 times.
✗ Branch 7 not taken.
 10704655 DBUG_PRINT("debug", ("is_current_stmt_binlog_format_row: %d",
11924 is_current_stmt_binlog_format_row()));
11925
2/2
✓ Branch 0 taken 10351869 times.
✓ Branch 1 taken 352764 times.
 10704639 if (is_current_stmt_binlog_format_row()) return 0;
11926 [[fallthrough]];
11927
11928 /*
11929 STMT_QUERY_TYPE means that the query must be logged in statement
11930 format; it cannot be logged in row format. This is typically
11931 used by DDL statements. It is an error to use this query type
11932 if current_stmt_binlog_format_row is row.
11933
11934 @todo Currently there are places that call this method with
11935 STMT_QUERY_TYPE and current_stmt_binlog_format is row. Fix those
11936 places and add assert to ensure correct behavior. /Sven
11937 */
11938 case THD::STMT_QUERY_TYPE:
11939 /*
11940 The MYSQL_BIN_LOG::write() function will set the STMT_END_F flag and
11941 flush the pending rows event if necessary.
11942 */
11943 {
11944 Query_log_event qinfo(this, query_arg, query_len, is_trans, direct,
11945
1/2
✓ Branch 0 taken 780897 times.
✗ Branch 1 not taken.
 781017 suppress_use, errcode);
11946 /*
11947 Binlog table maps will be irrelevant after a Query_log_event
11948 (they are just removed on the slave side) so after the query
11949 log event is written to the binary log, we pretend that no
11950 table maps were written.
11951 */
11952
1/2
✓ Branch 0 taken 780936 times.
✗ Branch 1 not taken.
 780897 int error = mysql_bin_log.write_event(&qinfo);
11953 780936 binlog_table_maps = 0;
11954 780936 return error;
11955 780936 }
11956 break;
11957
11958 ✗ case THD::QUERY_TYPE_COUNT:
11959 default:
11960 ✗ assert(0 <= qtype && qtype < QUERY_TYPE_COUNT);
11961 }
11962 ✗ return 0;
11963 11140753 }
11964
11965 217128 static const binlog_cache_mngr *get_cache_mngr(THD *thd) {
11966 const binlog_cache_mngr *cache_mngr =
11967
2/2
✓ Branch 0 taken 213408 times.
✓ Branch 1 taken 3720 times.
 217128 (thd && opt_bin_log)
11968
1/2
✓ Branch 0 taken 217128 times.
✗ Branch 1 not taken.
 434256 ? static_cast<binlog_cache_mngr *>(thd_get_ha_data(thd, binlog_hton))
11969 217128 : nullptr;
11970
11971 217128 return cache_mngr;
11972 }
11973
11974 108564 static int show_binlog_vars(THD *thd, SHOW_VAR *var,
11975 char *buff [[maybe_unused]]) {
11976 108564 mysql_mutex_assert_owner(&LOCK_status);
11977
11978 108564 const binlog_cache_mngr *cache_mngr = get_cache_mngr(thd);
11979
11980
6/6
✓ Branch 0 taken 26021 times.
✓ Branch 1 taken 82543 times.
✓ Branch 2 taken 73 times.
✓ Branch 3 taken 25948 times.
✓ Branch 4 taken 73 times.
✓ Branch 5 taken 108491 times.
 108564 if (cache_mngr && cache_mngr->has_consistent_snapshot()) {
11981 73 set_binlog_snapshot_file(cache_mngr->binlog_info.log_file_name);
11982 73 binlog_snapshot_position = cache_mngr->binlog_info.pos;
11983
2/2
✓ Branch 0 taken 106631 times.
✓ Branch 1 taken 1860 times.
 108491 } else if (mysql_bin_log.is_open()) {
11984 106631 set_binlog_snapshot_file(binlog_global_snapshot_file);
11985 106631 binlog_snapshot_position = binlog_global_snapshot_position;
11986 } else {
11987 1860 binlog_snapshot_file[0] = '\0';
11988 1860 binlog_snapshot_position = 0;
11989 }
11990 108564 var->type = SHOW_ARRAY;
11991 108564 var->value = reinterpret_cast<char *>(&binlog_status_vars_detail);
11992 108564 return 0;
11993 }
11994
11995 108564 static int show_binlog_snapshot_gtid_executed(
11996 THD *thd, SHOW_VAR *var, char *buff [[maybe_unused]]) {
11997 108564 mysql_mutex_assert_owner(&LOCK_status);
11998
11999 108564 const binlog_cache_mngr *cache_mngr = get_cache_mngr(thd);
12000
12001
6/6
✓ Branch 0 taken 26021 times.
✓ Branch 1 taken 82543 times.
✓ Branch 2 taken 73 times.
✓ Branch 3 taken 25948 times.
✓ Branch 4 taken 73 times.
✓ Branch 5 taken 108491 times.
 108564 if (cache_mngr && cache_mngr->has_consistent_snapshot()) {
12002 73 binlog_snapshot_gtid_executed = cache_mngr->snapshot_gtid_executed;
12003
2/2
✓ Branch 0 taken 106631 times.
✓ Branch 1 taken 1860 times.
 108491 } else if (mysql_bin_log.is_open()) {
12004 106631 binlog_snapshot_gtid_executed = "not-in-consistent-snapshot";
12005 } else {
12006 1860 binlog_snapshot_gtid_executed.clear();
12007 }
12008
12009 108564 var->type = SHOW_CHAR;
12010 108564 var->value = const_cast<char *>(binlog_snapshot_gtid_executed.c_str());
12011 108564 return 0;
12012 }
12013
12014 static SHOW_VAR binlog_status_vars_top[] = {
12015 {"Binlog", (char *)&show_binlog_vars, SHOW_FUNC, SHOW_SCOPE_GLOBAL},
12016 {"Binlog_snapshot_gtid_executed",
12017 (char *)&show_binlog_snapshot_gtid_executed, SHOW_FUNC, SHOW_SCOPE_GLOBAL},
12018 {NullS, NullS, SHOW_LONG, SHOW_SCOPE_GLOBAL}};
12019
12020 namespace {
12021 11851827 void finish_transaction_in_engines(THD *thd, bool all, bool run_after_commit) {
12022
2/2
✓ Branch 0 taken 5924859 times.
✓ Branch 1 taken 5927007 times.
 11851827 if (thd->get_transaction()->m_flags.commit_low) {
12023
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5924858 times.
 5924859 if (trx_coordinator::commit_in_engines(thd, all, run_after_commit))
12024 ✗ thd->commit_error = THD::CE_COMMIT_ERROR;
12025
2/2
✓ Branch 0 taken 287 times.
✓ Branch 1 taken 5926751 times.
 5927007 } else if (is_xa_rollback(thd)) {
12026
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287 times.
 287 if (trx_coordinator::rollback_in_engines(thd, all))
12027 ✗ thd->commit_error = THD::CE_COMMIT_ERROR;
12028 }
12029 11851896 }
12030 } // namespace
12031
12032 struct st_mysql_storage_engine binlog_storage_engine = {
12033 MYSQL_HANDLERTON_INTERFACE_VERSION};
12034
12035 /** @} */
12036
12037 mysql_declare_plugin(binlog){
12038 MYSQL_STORAGE_ENGINE_PLUGIN,
12039 &binlog_storage_engine,
12040 "binlog",
12041 PLUGIN_AUTHOR_ORACLE,
12042 "This is a pseudo storage engine to represent the binlog in a transaction",
12043 PLUGIN_LICENSE_GPL,
12044 binlog_init, /* Plugin Init */
12045 nullptr, /* Plugin Check uninstall */
12046 binlog_deinit, /* Plugin Deinit */
12047 0x0100 /* 1.0 */,
12048 binlog_status_vars_top, /* status variables */
12049 nullptr, /* system variables */
12050 nullptr, /* config options */
12051 0,
12052 } mysql_declare_plugin_end;
12053